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