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