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