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