* sign.c (update_keysig_packet): Policies and notations should be stripped
[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, 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     int special;
708   } table[] = {
709     { "DISP-NAME",    0x005B },
710     { "LOGIN-DATA",   0x005E },
711     { "DISP-LANG",    0x5F2D },
712     { "DISP-SEX",     0x5F35 },
713     { "PUBKEY-URL",   0x5F50 },
714     { "CHV-STATUS-1", 0x00C4, 1 },
715     { "CA-FPR-1",     0x00CA },
716     { "CA-FPR-2",     0x00CB },
717     { "CA-FPR-3",     0x00CC },
718     { NULL, 0 }
719   };
720
721
722   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
723     ;
724   if (!table[idx].name)
725     return gpg_error (GPG_ERR_INV_NAME); 
726
727   rc = verify_chv3 (app, pincb, pincb_arg);
728   if (rc)
729     return rc;
730
731   /* Flush the cache before writing it, so that the next get operation
732      will reread the data from the card and thus get synced in case of
733      errors (e.g. data truncated by the card). */
734   flush_cache_item (app, table[idx].tag);
735   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
736   if (rc)
737     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
738
739   if (table[idx].special == 1)
740     app->force_chv1 = (valuelen && *value == 0);
741
742   return rc;
743 }
744
745
746 /* Handle the PASSWD command. */
747 static int 
748 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
749                int (*pincb)(void*, const char *, char **),
750                void *pincb_arg)
751 {
752   int rc = 0;
753   int chvno = atoi (chvnostr);
754   char *pinvalue;
755
756   if (reset_mode && chvno == 3)
757     {
758       rc = gpg_error (GPG_ERR_INV_ID);
759       goto leave;
760     }
761   else if (reset_mode || chvno == 3)
762     {
763       /* we always require that the PIN is entered. */
764       app->did_chv3 = 0;
765       rc = verify_chv3 (app, pincb, pincb_arg);
766       if (rc)
767         goto leave;
768     }
769   else if (chvno == 1 || chvno == 2)
770     {
771       /* CHV1 and CVH2 should always have the same value, thus we
772          enforce it here.  */
773       int save_force = app->force_chv1;
774
775       app->force_chv1 = 0;
776       app->did_chv1 = 0;
777       app->did_chv2 = 0;
778       rc = verify_chv2 (app, pincb, pincb_arg);
779       app->force_chv1 = save_force;
780       if (rc)
781         goto leave;
782     }
783   else
784     {
785       rc = gpg_error (GPG_ERR_INV_ID);
786       goto leave;
787     }
788
789   if (chvno == 3)
790     app->did_chv3 = 0;
791   else
792     app->did_chv1 = app->did_chv2 = 0;
793
794   rc = pincb (pincb_arg, chvno == 3? "New Admin PIN" : "New PIN", &pinvalue); 
795   if (rc)
796     {
797       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
798       goto leave;
799     }
800
801   if (reset_mode)
802     {
803       rc = iso7816_reset_retry_counter (app->slot, 0x81,
804                                         pinvalue, strlen (pinvalue));
805       if (!rc)
806         rc = iso7816_reset_retry_counter (app->slot, 0x82,
807                                           pinvalue, strlen (pinvalue));
808     }
809   else
810     {
811       if (chvno == 1 || chvno == 2)
812         {
813           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
814                                               pinvalue, strlen (pinvalue));
815           if (!rc)
816             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
817                                                 pinvalue, strlen (pinvalue));
818         }
819       else
820         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
821                                             pinvalue, strlen (pinvalue));
822     }
823   xfree (pinvalue);
824   if (rc)
825     flush_cache_after_error (app);
826
827  leave:
828   return rc;
829 }
830
831
832
833 /* Handle the GENKEY command. */
834 static int 
835 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
836           int (*pincb)(void*, const char *, char **),
837           void *pincb_arg)
838 {
839   int rc;
840   int i;
841   char numbuf[30];
842   unsigned char fprbuf[20];
843   const unsigned char *fpr;
844   const unsigned char *keydata, *m, *e;
845   unsigned char *buffer;
846   size_t buflen, keydatalen, n, mlen, elen;
847   time_t created_at;
848   int keyno = atoi (keynostr);
849   int force = (flags & 1);
850   time_t start_at;
851
852   if (keyno < 1 || keyno > 3)
853     return gpg_error (GPG_ERR_INV_ID);
854   keyno--;
855
856   /* We flush the cache to increase the traffic before a key
857      generation.  This _might_ help a card to gather more entropy. */
858   flush_cache (app);
859
860   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
861   if (rc)
862     {
863       log_error ("error reading application data\n");
864       return gpg_error (GPG_ERR_GENERAL);
865     }
866   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
867   if (!fpr || n != 60)
868     {
869       rc = gpg_error (GPG_ERR_GENERAL);
870       log_error ("error reading fingerprint DO\n");
871       goto leave;
872     }
873   fpr += 20*keyno;
874   for (i=0; i < 20 && !fpr[i]; i++)
875     ;
876   if (i!=20 && !force)
877     {
878       rc = gpg_error (GPG_ERR_EEXIST);
879       log_error ("key already exists\n");
880       goto leave;
881     }
882   else if (i!=20)
883     log_info ("existing key will be replaced\n");
884   else
885     log_info ("generating new key\n");
886
887
888   rc = verify_chv3 (app, pincb, pincb_arg);
889   if (rc)
890     goto leave;
891
892   xfree (buffer); buffer = NULL;
893
894 #if 1
895   log_info ("please wait while key is being generated ...\n");
896   start_at = time (NULL);
897   rc = iso7816_generate_keypair 
898 #else
899 #warning key generation temporary replaced by reading an existing key.
900   rc = iso7816_read_public_key
901 #endif
902                               (app->slot, 
903                                  keyno == 0? "\xB6" :
904                                  keyno == 1? "\xB8" : "\xA4",
905                                  2,
906                                  &buffer, &buflen);
907   if (rc)
908     {
909       rc = gpg_error (GPG_ERR_CARD);
910       log_error ("generating key failed\n");
911       goto leave;
912     }
913   log_info ("key generation completed (%d seconds)\n",
914             (int)(time (NULL) - start_at));
915   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
916   if (!keydata)
917     {
918       rc = gpg_error (GPG_ERR_CARD);
919       log_error ("response does not contain the public key data\n");
920       goto leave;
921     }
922  
923   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
924   if (!m)
925     {
926       rc = gpg_error (GPG_ERR_CARD);
927       log_error ("response does not contain the RSA modulus\n");
928       goto leave;
929     }
930 /*    log_printhex ("RSA n:", m, mlen); */
931   send_key_data (ctrl, "n", m, mlen);
932
933   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
934   if (!e)
935     {
936       rc = gpg_error (GPG_ERR_CARD);
937       log_error ("response does not contain the RSA public exponent\n");
938       goto leave;
939     }
940 /*    log_printhex ("RSA e:", e, elen); */
941   send_key_data (ctrl, "e", e, elen);
942
943   created_at = gnupg_get_time ();
944   sprintf (numbuf, "%lu", (unsigned long)created_at);
945   send_status_info (ctrl, "KEY-CREATED-AT",
946                     numbuf, (size_t)strlen(numbuf), NULL, 0);
947
948   rc = store_fpr (app->slot, keyno, (u32)created_at,
949                   m, mlen, e, elen, fprbuf, app->card_version);
950   if (rc)
951     goto leave;
952   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
953
954
955  leave:
956   xfree (buffer);
957   return rc;
958 }
959
960
961 static unsigned long
962 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
963 {
964   unsigned long ul;
965
966   if (valuelen == 3 )
967     ul = (value[0] << 16) | (value[1] << 8) | value[2];
968   else
969     {
970       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
971       ul = 0;
972     }
973   return ul;
974 }
975
976 static unsigned long
977 get_sig_counter (APP app)
978 {
979   void *relptr;
980   unsigned char *value;
981   size_t valuelen;
982   unsigned long ul;
983
984   relptr = get_one_do (app, 0x0093, &value, &valuelen);
985   if (!relptr)
986     return 0;
987   ul = convert_sig_counter_value (value, valuelen);
988   xfree (relptr);
989   return ul;
990 }
991
992 static int
993 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
994 {
995   const unsigned char *fpr;
996   unsigned char *buffer;
997   size_t buflen, n;
998   int rc, i;
999   
1000   assert (keyno >= 1 && keyno <= 3);
1001
1002   rc = get_cached_data (app, 0x006E, &buffer, &buflen);
1003   if (rc)
1004     {
1005       log_error ("error reading application data\n");
1006       return gpg_error (GPG_ERR_GENERAL);
1007     }
1008   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1009   if (!fpr || n != 60)
1010     {
1011       xfree (buffer);
1012       log_error ("error reading fingerprint DO\n");
1013       return gpg_error (GPG_ERR_GENERAL);
1014     }
1015   fpr += (keyno-1)*20;
1016   for (i=0; i < 20; i++)
1017     if (sha1fpr[i] != fpr[i])
1018       {
1019         xfree (buffer);
1020         return gpg_error (GPG_ERR_WRONG_SECKEY);
1021       }
1022   xfree (buffer);
1023   return 0;
1024 }
1025
1026
1027   /* If a fingerprint has been specified check it against the one on
1028      the card.  This is allows for a meaningful error message in case
1029      the key on the card has been replaced but the shadow information
1030      known to gpg was not updated.  If there is no fingerprint we
1031      assume that this is okay. */
1032 static int
1033 check_against_given_fingerprint (APP app, const char *fpr, int keyno)
1034 {
1035   unsigned char tmp[20];
1036   const char *s;
1037   int n;
1038
1039   for (s=fpr, n=0; hexdigitp (s); s++, n++)
1040     ;
1041   if (n != 40)
1042     return gpg_error (GPG_ERR_INV_ID);
1043   else if (!*s)
1044     ; /* okay */
1045   else
1046     return gpg_error (GPG_ERR_INV_ID);
1047
1048   for (s=fpr, n=0; n < 20; s += 2, n++)
1049         tmp[n] = xtoi_2 (s);
1050   return compare_fingerprint (app, keyno, tmp);
1051 }
1052
1053
1054
1055 /* Compute a digital signature on INDATA which is expected to be the
1056    raw message digest. For this application the KEYIDSTR consists of
1057    the serialnumber and the fingerprint delimited by a slash.
1058
1059    Note that this fucntion may return the error code
1060    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1061    not match the one required for the requested action (e.g. the
1062    serial number does not match). */
1063 static int 
1064 do_sign (APP app, const char *keyidstr, int hashalgo,
1065          int (*pincb)(void*, const char *, char **),
1066          void *pincb_arg,
1067          const void *indata, size_t indatalen,
1068          unsigned char **outdata, size_t *outdatalen )
1069 {
1070   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
1071   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
1072     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
1073   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
1074   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
1075     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
1076   int rc;
1077   unsigned char data[35];
1078   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1079   const char *s;
1080   int n;
1081   const char *fpr = NULL;
1082   unsigned long sigcount;
1083
1084   if (!keyidstr || !*keyidstr)
1085     return gpg_error (GPG_ERR_INV_VALUE);
1086   if (indatalen != 20)
1087     return gpg_error (GPG_ERR_INV_VALUE);
1088
1089   /* Check whether an OpenPGP card of any version has been requested. */
1090   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1091     return gpg_error (GPG_ERR_INV_ID);
1092   
1093   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1094     ;
1095   if (n != 32)
1096     return gpg_error (GPG_ERR_INV_ID);
1097   else if (!*s)
1098     ; /* no fingerprint given: we allow this for now. */
1099   else if (*s == '/')
1100     fpr = s + 1; 
1101   else
1102     return gpg_error (GPG_ERR_INV_ID);
1103
1104   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1105     tmp_sn[n] = xtoi_2 (s);
1106
1107   if (app->serialnolen != 16)
1108     return gpg_error (GPG_ERR_INV_CARD);
1109   if (memcmp (app->serialno, tmp_sn, 16))
1110     return gpg_error (GPG_ERR_WRONG_CARD);
1111
1112   /* If a fingerprint has been specified check it against the one on
1113      the card.  This is allows for a meaningful error message in case
1114      the key on the card has been replaced but the shadow information
1115      known to gpg was not updated.  If there is no fingerprint, gpg
1116      will detect a bogus signature anyway due to the
1117      verify-after-signing feature. */
1118   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
1119   if (rc)
1120     return rc;
1121
1122   if (hashalgo == GCRY_MD_SHA1)
1123     memcpy (data, sha1_prefix, 15);
1124   else if (hashalgo == GCRY_MD_RMD160)
1125     memcpy (data, rmd160_prefix, 15);
1126   else 
1127     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1128   memcpy (data+15, indata, indatalen);
1129
1130   sigcount = get_sig_counter (app);
1131   log_info ("signatures created so far: %lu\n", sigcount);
1132
1133   if (!app->did_chv1 || app->force_chv1 ) 
1134     {
1135       char *pinvalue;
1136
1137       {
1138         char *prompt;
1139         if (asprintf (&prompt, "PIN [sigs done: %lu]", sigcount) < 0)
1140           return gpg_error_from_errno (errno);
1141         rc = pincb (pincb_arg, prompt, &pinvalue); 
1142         free (prompt);
1143       }
1144       if (rc)
1145         {
1146           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1147           return rc;
1148         }
1149
1150       if (strlen (pinvalue) < 6)
1151         {
1152           log_error ("prassphrase (CHV1) is too short; minimum length is 6\n");
1153           xfree (pinvalue);
1154           return gpg_error (GPG_ERR_BAD_PIN);
1155         }
1156
1157       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1158       if (rc)
1159         {
1160           log_error ("verify CHV1 failed\n");
1161           xfree (pinvalue);
1162           flush_cache_after_error (app);
1163           return rc;
1164         }
1165       app->did_chv1 = 1;
1166       if (!app->did_chv2)
1167         {
1168           /* We should also verify CHV2. */
1169           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1170           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1171             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1172           if (rc)
1173             {
1174               log_error ("verify CHV2 failed\n");
1175               xfree (pinvalue);
1176               flush_cache_after_error (app);
1177               return rc;
1178             }
1179           app->did_chv2 = 1;
1180         }
1181       xfree (pinvalue);
1182     }
1183
1184   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1185   return rc;
1186 }
1187
1188 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1189    on INDATA which is expected to be the raw message digest. For this
1190    application the KEYIDSTR consists of the serialnumber and the
1191    fingerprint delimited by a slash.
1192
1193    Note that this fucntion may return the error code
1194    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1195    not match the one required for the requested action (e.g. the
1196    serial number does not match). */
1197 static int 
1198 do_auth (APP app, const char *keyidstr,
1199          int (*pincb)(void*, const char *, char **),
1200          void *pincb_arg,
1201          const void *indata, size_t indatalen,
1202          unsigned char **outdata, size_t *outdatalen )
1203 {
1204   int rc;
1205   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1206   const char *s;
1207   int n;
1208   const char *fpr = NULL;
1209
1210   if (!keyidstr || !*keyidstr)
1211     return gpg_error (GPG_ERR_INV_VALUE);
1212   if (indatalen > 50) /* For a 1024 bit key. */
1213     return gpg_error (GPG_ERR_INV_VALUE);
1214
1215   /* Check whether an OpenPGP card of any version has been requested. */
1216   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1217     return gpg_error (GPG_ERR_INV_ID);
1218   
1219   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1220     ;
1221   if (n != 32)
1222     return gpg_error (GPG_ERR_INV_ID);
1223   else if (!*s)
1224     ; /* no fingerprint given: we allow this for now. */
1225   else if (*s == '/')
1226     fpr = s + 1; 
1227   else
1228     return gpg_error (GPG_ERR_INV_ID);
1229
1230   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1231     tmp_sn[n] = xtoi_2 (s);
1232
1233   if (app->serialnolen != 16)
1234     return gpg_error (GPG_ERR_INV_CARD);
1235   if (memcmp (app->serialno, tmp_sn, 16))
1236     return gpg_error (GPG_ERR_WRONG_CARD);
1237
1238   /* If a fingerprint has been specified check it against the one on
1239      the card.  This is allows for a meaningful error message in case
1240      the key on the card has been replaced but the shadow information
1241      known to gpg was not updated.  If there is no fingerprint, gpg
1242      will detect a bogus signature anyway due to the
1243      verify-after-signing feature. */
1244   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
1245   if (rc)
1246     return rc;
1247
1248   rc = verify_chv2 (app, pincb, pincb_arg);
1249   if (!rc)
1250     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1251                                         outdata, outdatalen);
1252   return rc;
1253 }
1254
1255
1256 static int 
1257 do_decipher (APP app, const char *keyidstr,
1258              int (pincb)(void*, const char *, char **),
1259              void *pincb_arg,
1260              const void *indata, size_t indatalen,
1261              unsigned char **outdata, size_t *outdatalen )
1262 {
1263   int rc;
1264   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1265   const char *s;
1266   int n;
1267   const char *fpr = NULL;
1268
1269   if (!keyidstr || !*keyidstr || !indatalen)
1270     return gpg_error (GPG_ERR_INV_VALUE);
1271
1272   /* Check whether an OpenPGP card of any version has been requested. */
1273   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1274     return gpg_error (GPG_ERR_INV_ID);
1275   
1276   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1277     ;
1278   if (n != 32)
1279     return gpg_error (GPG_ERR_INV_ID);
1280   else if (!*s)
1281     ; /* no fingerprint given: we allow this for now. */
1282   else if (*s == '/')
1283     fpr = s + 1; 
1284   else
1285     return gpg_error (GPG_ERR_INV_ID);
1286
1287   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1288     tmp_sn[n] = xtoi_2 (s);
1289
1290   if (app->serialnolen != 16)
1291     return gpg_error (GPG_ERR_INV_CARD);
1292   if (memcmp (app->serialno, tmp_sn, 16))
1293     return gpg_error (GPG_ERR_WRONG_CARD);
1294
1295   /* If a fingerprint has been specified check it against the one on
1296      the card.  This is allows for a meaningful error message in case
1297      the key on the card has been replaced but the shadow information
1298      known to gpg was not updated.  If there is no fingerprint, the
1299      decryption will won't produce the right plaintext anyway. */
1300   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
1301   if (rc)
1302     return rc;
1303
1304   rc = verify_chv2 (app, pincb, pincb_arg);
1305   if (!rc)
1306     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
1307                            outdata, outdatalen);
1308   return rc;
1309 }
1310
1311
1312 /* Perform a simple verify operation for CHV1 and CHV2, so that
1313    further operations won't ask for CHV2 and it is possible to do a
1314    cheap check on the PIN: If there is something wrong with the PIN
1315    entry system, only the regular CHV will get blocked and not the
1316    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1317    optional fingerprint part will be ignored. */
1318 static int 
1319 do_check_pin (APP app, const char *keyidstr,
1320               int (pincb)(void*, const char *, char **),
1321               void *pincb_arg)
1322 {
1323   unsigned char tmp_sn[20]; 
1324   const char *s;
1325   int n;
1326
1327   if (!keyidstr || !*keyidstr)
1328     return gpg_error (GPG_ERR_INV_VALUE);
1329
1330   /* Check whether an OpenPGP card of any version has been requested. */
1331   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1332     return gpg_error (GPG_ERR_INV_ID);
1333   
1334   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1335     ;
1336   if (n != 32)
1337     return gpg_error (GPG_ERR_INV_ID);
1338   else if (!*s)
1339     ; /* No fingerprint given: we allow this for now. */
1340   else if (*s == '/')
1341     ; /* We ignore a fingerprint. */
1342   else
1343     return gpg_error (GPG_ERR_INV_ID);
1344
1345   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1346     tmp_sn[n] = xtoi_2 (s);
1347
1348   if (app->serialnolen != 16)
1349     return gpg_error (GPG_ERR_INV_CARD);
1350   if (memcmp (app->serialno, tmp_sn, 16))
1351     return gpg_error (GPG_ERR_WRONG_CARD);
1352   /* Yes, there is a race conditions: The user might pull the card
1353      right here and we won't notice that.  However this is not a
1354      problem and the check above is merely for a graceful failure
1355      between operations. */
1356
1357   return verify_chv2 (app, pincb, pincb_arg);
1358 }
1359
1360
1361
1362
1363 /* Select the OpenPGP application on the card in SLOT.  This function
1364    must be used before any other OpenPGP application functions. */
1365 int
1366 app_select_openpgp (APP app)
1367 {
1368   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1369   int slot = app->slot;
1370   int rc;
1371   unsigned char *buffer;
1372   size_t buflen;
1373   void *relptr;
1374   
1375   rc = iso7816_select_application (slot, aid, sizeof aid);
1376   if (!rc)
1377     {
1378       app->apptype = "OPENPGP";
1379
1380       app->did_chv1 = 0;
1381       app->did_chv2 = 0;
1382       app->did_chv3 = 0;
1383
1384       /* The OpenPGP card returns the serial number as part of the
1385          AID; because we prefer to use OpenPGP serial numbers, we
1386          replace a possibly already set one from a EF.GDO with this
1387          one.  Note, that for current OpenPGP cards, no EF.GDO exists
1388          and thus it won't matter at all. */
1389       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1390       if (rc)
1391         goto leave;
1392       if (opt.verbose)
1393         {
1394           log_info ("got AID: ");
1395           log_printhex ("", buffer, buflen);
1396         }
1397
1398       app->card_version = buffer[6] << 8;
1399       app->card_version |= buffer[7];
1400       xfree (app->serialno);
1401       app->serialno = buffer;
1402       app->serialnolen = buflen;
1403       buffer = NULL;
1404
1405       relptr = get_one_do (app, 0x00C4, &buffer, &buflen);
1406       if (!relptr)
1407         {
1408           log_error ("can't access CHV Status Bytes - invalid OpenPGP card?\n");
1409           goto leave;
1410         }
1411       app->force_chv1 = (buflen && *buffer == 0);
1412       xfree (relptr);
1413         
1414       if (opt.verbose > 1)
1415         dump_all_do (slot);
1416
1417       app->fnc.deinit = do_deinit;
1418       app->fnc.learn_status = do_learn_status;
1419       app->fnc.readcert = NULL;
1420       app->fnc.getattr = do_getattr;
1421       app->fnc.setattr = do_setattr;
1422       app->fnc.genkey = do_genkey;
1423       app->fnc.sign = do_sign;
1424       app->fnc.auth = do_auth;
1425       app->fnc.decipher = do_decipher;
1426       app->fnc.change_pin = do_change_pin;
1427       app->fnc.check_pin = do_check_pin;
1428    }
1429
1430 leave:
1431   return rc;
1432 }
1433
1434
1435
1436 /* This function is a hack to retrieve essential information about the
1437    card to be displayed by simple tools.  It mostly resembles what the
1438    LEARN command returns. All parameters return allocated strings or
1439    buffers or NULL if the data object is not available.  All returned
1440    values are sanitized. */
1441 int
1442 app_openpgp_cardinfo (APP app,
1443                       char **serialno,
1444                       char **disp_name,
1445                       char **pubkey_url,
1446                       unsigned char **fpr1,
1447                       unsigned char **fpr2,
1448                       unsigned char **fpr3)
1449 {
1450   int rc;
1451   void *relptr;
1452   unsigned char *value;
1453   size_t valuelen;
1454
1455   if (serialno)
1456     {
1457       time_t dummy;
1458
1459       *serialno = NULL;
1460       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1461       if (rc)
1462         {
1463           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1464           return rc;
1465         }
1466     }
1467       
1468   if (disp_name)
1469     {
1470       *disp_name = NULL;
1471       relptr = get_one_do (app, 0x005B, &value, &valuelen);
1472       if (relptr)
1473         {
1474           *disp_name = make_printable_string (value, valuelen, 0);
1475           xfree (relptr);
1476         }
1477     }
1478
1479   if (pubkey_url)
1480     {
1481       *pubkey_url = NULL;
1482       relptr = get_one_do (app, 0x5F50, &value, &valuelen);
1483       if (relptr)
1484         {
1485           *pubkey_url = make_printable_string (value, valuelen, 0);
1486           xfree (relptr);
1487         }
1488     }
1489
1490   if (fpr1)
1491     *fpr1 = NULL;
1492   if (fpr2)
1493     *fpr2 = NULL;
1494   if (fpr3)
1495     *fpr3 = NULL;
1496   relptr = get_one_do (app, 0x00C5, &value, &valuelen);
1497   if (relptr && valuelen >= 60)
1498     {
1499       if (fpr1)
1500         {
1501           *fpr1 = xmalloc (20);
1502           memcpy (*fpr1, value +  0, 20);
1503         }
1504       if (fpr2)
1505         {
1506           *fpr2 = xmalloc (20);
1507           memcpy (*fpr2, value + 20, 20);
1508         }
1509       if (fpr3)
1510         {
1511           *fpr3 = xmalloc (20);
1512           memcpy (*fpr3, value + 40, 20);
1513         }
1514     }
1515   xfree (relptr);
1516
1517   return 0;
1518 }
1519
1520
1521
1522 /* This function is currently only used by the sc-copykeys program to
1523    store a key on the smartcard.  APP ist the application handle,
1524    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1525    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1526    the key template to store. CREATED_AT is the timestamp used to
1527    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1528    RSA public exponent. This function silently overwrites an existing
1529    key.*/
1530 int 
1531 app_openpgp_storekey (APP app, int keyno,
1532                       unsigned char *template, size_t template_len,
1533                       time_t created_at,
1534                       const unsigned char *m, size_t mlen,
1535                       const unsigned char *e, size_t elen,
1536                       int (*pincb)(void*, const char *, char **),
1537                       void *pincb_arg)
1538 {
1539   int rc;
1540   unsigned char fprbuf[20];
1541
1542   if (keyno < 1 || keyno > 3)
1543     return gpg_error (GPG_ERR_INV_ID);
1544   keyno--;
1545
1546   rc = verify_chv3 (app, pincb, pincb_arg);
1547   if (rc)
1548     goto leave;
1549
1550
1551   rc = iso7816_put_data (app->slot,
1552                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1553                          template, template_len);
1554   if (rc)
1555     {
1556       log_error ("failed to store the key: rc=%s\n", gpg_strerror (rc));
1557       rc = gpg_error (GPG_ERR_CARD);
1558       goto leave;
1559     }
1560  
1561 /*    log_printhex ("RSA n:", m, mlen);  */
1562 /*    log_printhex ("RSA e:", e, elen);  */
1563
1564   rc = store_fpr (app->slot, keyno, (u32)created_at,
1565                   m, mlen, e, elen, fprbuf, app->card_version);
1566
1567  leave:
1568   return rc;
1569 }
1570
1571
1572 /* Utility function for external tools: Read the public RSA key at
1573    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1574 int 
1575 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1576                      unsigned char **e, size_t *elen)
1577 {
1578   int rc;
1579   const unsigned char *keydata, *a;
1580   unsigned char *buffer;
1581   size_t buflen, keydatalen, alen;
1582
1583   *m = NULL;
1584   *e = NULL;
1585
1586   if (keyno < 1 || keyno > 3)
1587     return gpg_error (GPG_ERR_INV_ID);
1588   keyno--;
1589
1590   rc = iso7816_read_public_key(app->slot, 
1591                                keyno == 0? "\xB6" :
1592                                keyno == 1? "\xB8" : "\xA4",
1593                                2,
1594                                &buffer, &buflen);
1595   if (rc)
1596     {
1597       rc = gpg_error (GPG_ERR_CARD);
1598       log_error ("reading key failed\n");
1599       goto leave;
1600     }
1601
1602   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1603   if (!keydata)
1604     {
1605       log_error ("response does not contain the public key data\n");
1606       rc = gpg_error (GPG_ERR_CARD);
1607       goto leave;
1608     }
1609  
1610   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
1611   if (!a)
1612     {
1613       log_error ("response does not contain the RSA modulus\n");
1614       rc = gpg_error (GPG_ERR_CARD);
1615       goto leave;
1616     }
1617   *mlen = alen;
1618   *m = xmalloc (alen);
1619   memcpy (*m, a, alen);
1620   
1621   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
1622   if (!e)
1623     {
1624       log_error ("response does not contain the RSA public exponent\n");
1625       rc = gpg_error (GPG_ERR_CARD);
1626       goto leave;
1627     }
1628   *elen = alen;
1629   *e = xmalloc (alen);
1630   memcpy (*e, a, alen);
1631
1632  leave:
1633   xfree (buffer);
1634   if (rc)
1635     { 
1636       xfree (*m); *m = NULL;
1637       xfree (*e); *e = NULL;
1638     }
1639   return rc;
1640 }