* app-openpgp.c (do_sign): Replace asprintf by direct allocation.
[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  * $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 (_("passphrase (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 #define PROMPTSTRING  _("PIN [sigs done: %lu]")
1302
1303         prompt = malloc (strlen (PROMPTSTRING) + 50);
1304         if (!prompt)
1305           return gpg_error_from_errno (errno);
1306         sprintf (prompt, PROMPTSTRING, sigcount);
1307         rc = pincb (pincb_arg, prompt, &pinvalue); 
1308         free (prompt);
1309 #undef PROMPTSTRING
1310       }
1311       if (rc)
1312         {
1313           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1314           return rc;
1315         }
1316
1317       if (strlen (pinvalue) < 6)
1318         {
1319           log_error (_("PIN for CHV%d is too short;"
1320                        " minimum length is %d\n"), 1, 6);
1321           xfree (pinvalue);
1322           return gpg_error (GPG_ERR_BAD_PIN);
1323         }
1324
1325       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1326       if (rc)
1327         {
1328           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1329           xfree (pinvalue);
1330           flush_cache_after_error (app);
1331           return rc;
1332         }
1333       app->did_chv1 = 1;
1334       if (!app->did_chv2)
1335         {
1336           /* We should also verify CHV2. */
1337           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1338           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1339             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1340           if (rc)
1341             {
1342               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1343               xfree (pinvalue);
1344               flush_cache_after_error (app);
1345               return rc;
1346             }
1347           app->did_chv2 = 1;
1348         }
1349       xfree (pinvalue);
1350     }
1351
1352   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1353   return rc;
1354 }
1355
1356 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1357    on INDATA which is expected to be the raw message digest. For this
1358    application the KEYIDSTR consists of the serialnumber and the
1359    fingerprint delimited by a slash.
1360
1361    Note that this fucntion may return the error code
1362    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1363    not match the one required for the requested action (e.g. the
1364    serial number does not match). */
1365 static int 
1366 do_auth (app_t app, const char *keyidstr,
1367          int (*pincb)(void*, const char *, char **),
1368          void *pincb_arg,
1369          const void *indata, size_t indatalen,
1370          unsigned char **outdata, size_t *outdatalen )
1371 {
1372   int rc;
1373   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1374   const char *s;
1375   int n;
1376   const char *fpr = NULL;
1377
1378   if (!keyidstr || !*keyidstr)
1379     return gpg_error (GPG_ERR_INV_VALUE);
1380   if (indatalen > 50) /* For a 1024 bit key. */
1381     return gpg_error (GPG_ERR_INV_VALUE);
1382
1383   /* Check whether an OpenPGP card of any version has been requested. */
1384   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1385     return gpg_error (GPG_ERR_INV_ID);
1386   
1387   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1388     ;
1389   if (n != 32)
1390     return gpg_error (GPG_ERR_INV_ID);
1391   else if (!*s)
1392     ; /* no fingerprint given: we allow this for now. */
1393   else if (*s == '/')
1394     fpr = s + 1; 
1395   else
1396     return gpg_error (GPG_ERR_INV_ID);
1397
1398   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1399     tmp_sn[n] = xtoi_2 (s);
1400
1401   if (app->serialnolen != 16)
1402     return gpg_error (GPG_ERR_INV_CARD);
1403   if (memcmp (app->serialno, tmp_sn, 16))
1404     return gpg_error (GPG_ERR_WRONG_CARD);
1405
1406   /* If a fingerprint has been specified check it against the one on
1407      the card.  This is allows for a meaningful error message in case
1408      the key on the card has been replaced but the shadow information
1409      known to gpg was not updated.  If there is no fingerprint, gpg
1410      will detect a bogus signature anyway due to the
1411      verify-after-signing feature. */
1412   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
1413   if (rc)
1414     return rc;
1415
1416   rc = verify_chv2 (app, pincb, pincb_arg);
1417   if (!rc)
1418     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1419                                         outdata, outdatalen);
1420   return rc;
1421 }
1422
1423
1424 static int 
1425 do_decipher (app_t app, const char *keyidstr,
1426              int (pincb)(void*, const char *, char **),
1427              void *pincb_arg,
1428              const void *indata, size_t indatalen,
1429              unsigned char **outdata, size_t *outdatalen )
1430 {
1431   int rc;
1432   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1433   const char *s;
1434   int n;
1435   const char *fpr = NULL;
1436
1437   if (!keyidstr || !*keyidstr || !indatalen)
1438     return gpg_error (GPG_ERR_INV_VALUE);
1439
1440   /* Check whether an OpenPGP card of any version has been requested. */
1441   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1442     return gpg_error (GPG_ERR_INV_ID);
1443   
1444   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1445     ;
1446   if (n != 32)
1447     return gpg_error (GPG_ERR_INV_ID);
1448   else if (!*s)
1449     ; /* no fingerprint given: we allow this for now. */
1450   else if (*s == '/')
1451     fpr = s + 1; 
1452   else
1453     return gpg_error (GPG_ERR_INV_ID);
1454
1455   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1456     tmp_sn[n] = xtoi_2 (s);
1457
1458   if (app->serialnolen != 16)
1459     return gpg_error (GPG_ERR_INV_CARD);
1460   if (memcmp (app->serialno, tmp_sn, 16))
1461     return gpg_error (GPG_ERR_WRONG_CARD);
1462
1463   /* If a fingerprint has been specified check it against the one on
1464      the card.  This is allows for a meaningful error message in case
1465      the key on the card has been replaced but the shadow information
1466      known to gpg was not updated.  If there is no fingerprint, the
1467      decryption will won't produce the right plaintext anyway. */
1468   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
1469   if (rc)
1470     return rc;
1471
1472   rc = verify_chv2 (app, pincb, pincb_arg);
1473   if (!rc)
1474     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
1475                            outdata, outdatalen);
1476   return rc;
1477 }
1478
1479
1480 /* Perform a simple verify operation for CHV1 and CHV2, so that
1481    further operations won't ask for CHV2 and it is possible to do a
1482    cheap check on the PIN: If there is something wrong with the PIN
1483    entry system, only the regular CHV will get blocked and not the
1484    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1485    optional fingerprint part will be ignored. */
1486 static int 
1487 do_check_pin (app_t app, const char *keyidstr,
1488               int (pincb)(void*, const char *, char **),
1489               void *pincb_arg)
1490 {
1491   unsigned char tmp_sn[20]; 
1492   const char *s;
1493   int n;
1494
1495   if (!keyidstr || !*keyidstr)
1496     return gpg_error (GPG_ERR_INV_VALUE);
1497
1498   /* Check whether an OpenPGP card of any version has been requested. */
1499   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1500     return gpg_error (GPG_ERR_INV_ID);
1501   
1502   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1503     ;
1504   if (n != 32)
1505     return gpg_error (GPG_ERR_INV_ID);
1506   else if (!*s)
1507     ; /* No fingerprint given: we allow this for now. */
1508   else if (*s == '/')
1509     ; /* We ignore a fingerprint. */
1510   else
1511     return gpg_error (GPG_ERR_INV_ID);
1512
1513   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1514     tmp_sn[n] = xtoi_2 (s);
1515
1516   if (app->serialnolen != 16)
1517     return gpg_error (GPG_ERR_INV_CARD);
1518   if (memcmp (app->serialno, tmp_sn, 16))
1519     return gpg_error (GPG_ERR_WRONG_CARD);
1520   /* Yes, there is a race conditions: The user might pull the card
1521      right here and we won't notice that.  However this is not a
1522      problem and the check above is merely for a graceful failure
1523      between operations. */
1524
1525   return verify_chv2 (app, pincb, pincb_arg);
1526 }
1527
1528
1529
1530
1531 /* Select the OpenPGP application on the card in SLOT.  This function
1532    must be used before any other OpenPGP application functions. */
1533 int
1534 app_select_openpgp (app_t app)
1535 {
1536   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1537   int slot = app->slot;
1538   int rc;
1539   unsigned char *buffer;
1540   size_t buflen;
1541   void *relptr;
1542   
1543   rc = iso7816_select_application (slot, aid, sizeof aid);
1544   if (!rc)
1545     {
1546       unsigned int manufacturer;
1547
1548       app->apptype = "OPENPGP";
1549
1550       app->did_chv1 = 0;
1551       app->did_chv2 = 0;
1552       app->did_chv3 = 0;
1553       app->app_local = NULL;
1554
1555       /* The OpenPGP card returns the serial number as part of the
1556          AID; because we prefer to use OpenPGP serial numbers, we
1557          replace a possibly already set one from a EF.GDO with this
1558          one.  Note, that for current OpenPGP cards, no EF.GDO exists
1559          and thus it won't matter at all. */
1560       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1561       if (rc)
1562         goto leave;
1563       if (opt.verbose)
1564         {
1565           log_info ("AID: ");
1566           log_printhex ("", buffer, buflen);
1567         }
1568
1569       app->card_version = buffer[6] << 8;
1570       app->card_version |= buffer[7];
1571       manufacturer = (buffer[8]<<8 | buffer[9]);
1572
1573       xfree (app->serialno);
1574       app->serialno = buffer;
1575       app->serialnolen = buflen;
1576       buffer = NULL;
1577       app->app_local = xtrycalloc (1, sizeof *app->app_local);
1578       if (!app->app_local)
1579         {
1580           rc = gpg_error (gpg_err_code_from_errno (errno));
1581           goto leave;
1582         }
1583
1584       relptr = get_one_do (app, 0x00C4, &buffer, &buflen);
1585       if (!relptr)
1586         {
1587           log_error (_("can't access %s - invalid OpenPGP card?\n"),
1588                      "CHV Status Bytes");
1589           goto leave;
1590         }
1591       app->force_chv1 = (buflen && *buffer == 0);
1592       xfree (relptr);
1593
1594       relptr = get_one_do (app, 0x00C0, &buffer, &buflen);
1595       if (!relptr)
1596         {
1597           log_error (_("can't access %s - invalid OpenPGP card?\n"),
1598                      "Extended Capability Flags" );
1599           goto leave;
1600         }
1601       if (buflen)
1602         {
1603           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
1604           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
1605           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
1606           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
1607         }
1608       xfree (relptr);
1609       
1610       /* Some of the first cards accidently don't set the
1611          CHANGE_FORCE_CHV bit but allow it anyway. */
1612       if (app->card_version <= 0x0100 && manufacturer == 1)
1613         app->app_local->extcap.change_force_chv = 1;
1614
1615       parse_login_data (app);
1616
1617       if (opt.verbose > 1)
1618         dump_all_do (slot);
1619
1620       app->fnc.deinit = do_deinit;
1621       app->fnc.learn_status = do_learn_status;
1622       app->fnc.readcert = NULL;
1623       app->fnc.getattr = do_getattr;
1624       app->fnc.setattr = do_setattr;
1625       app->fnc.genkey = do_genkey;
1626       app->fnc.sign = do_sign;
1627       app->fnc.auth = do_auth;
1628       app->fnc.decipher = do_decipher;
1629       app->fnc.change_pin = do_change_pin;
1630       app->fnc.check_pin = do_check_pin;
1631    }
1632
1633 leave:
1634   if (rc)
1635     do_deinit (app);
1636   return rc;
1637 }
1638
1639
1640
1641 /* This function is a hack to retrieve essential information about the
1642    card to be displayed by simple tools.  It mostly resembles what the
1643    LEARN command returns. All parameters return allocated strings or
1644    buffers or NULL if the data object is not available.  All returned
1645    values are sanitized. */
1646 int
1647 app_openpgp_cardinfo (app_t app,
1648                       char **serialno,
1649                       char **disp_name,
1650                       char **pubkey_url,
1651                       unsigned char **fpr1,
1652                       unsigned char **fpr2,
1653                       unsigned char **fpr3)
1654 {
1655   int rc;
1656   void *relptr;
1657   unsigned char *value;
1658   size_t valuelen;
1659
1660   if (serialno)
1661     {
1662       time_t dummy;
1663
1664       *serialno = NULL;
1665       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1666       if (rc)
1667         {
1668           log_error (_("error getting serial number: %s\n"),
1669                      gpg_strerror (rc));
1670           return rc;
1671         }
1672     }
1673       
1674   if (disp_name)
1675     {
1676       *disp_name = NULL;
1677       relptr = get_one_do (app, 0x005B, &value, &valuelen);
1678       if (relptr)
1679         {
1680           *disp_name = make_printable_string (value, valuelen, 0);
1681           xfree (relptr);
1682         }
1683     }
1684
1685   if (pubkey_url)
1686     {
1687       *pubkey_url = NULL;
1688       relptr = get_one_do (app, 0x5F50, &value, &valuelen);
1689       if (relptr)
1690         {
1691           *pubkey_url = make_printable_string (value, valuelen, 0);
1692           xfree (relptr);
1693         }
1694     }
1695
1696   if (fpr1)
1697     *fpr1 = NULL;
1698   if (fpr2)
1699     *fpr2 = NULL;
1700   if (fpr3)
1701     *fpr3 = NULL;
1702   relptr = get_one_do (app, 0x00C5, &value, &valuelen);
1703   if (relptr && valuelen >= 60)
1704     {
1705       if (fpr1)
1706         {
1707           *fpr1 = xmalloc (20);
1708           memcpy (*fpr1, value +  0, 20);
1709         }
1710       if (fpr2)
1711         {
1712           *fpr2 = xmalloc (20);
1713           memcpy (*fpr2, value + 20, 20);
1714         }
1715       if (fpr3)
1716         {
1717           *fpr3 = xmalloc (20);
1718           memcpy (*fpr3, value + 40, 20);
1719         }
1720     }
1721   xfree (relptr);
1722
1723   return 0;
1724 }
1725
1726
1727
1728 /* This function is currently only used by the sc-copykeys program to
1729    store a key on the smartcard.  app_t ist the application handle,
1730    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1731    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1732    the key template to store. CREATED_AT is the timestamp used to
1733    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1734    RSA public exponent. This function silently overwrites an existing
1735    key.*/
1736 int 
1737 app_openpgp_storekey (app_t app, int keyno,
1738                       unsigned char *template, size_t template_len,
1739                       time_t created_at,
1740                       const unsigned char *m, size_t mlen,
1741                       const unsigned char *e, size_t elen,
1742                       int (*pincb)(void*, const char *, char **),
1743                       void *pincb_arg)
1744 {
1745   int rc;
1746   unsigned char fprbuf[20];
1747
1748   if (keyno < 1 || keyno > 3)
1749     return gpg_error (GPG_ERR_INV_ID);
1750   keyno--;
1751
1752   rc = verify_chv3 (app, pincb, pincb_arg);
1753   if (rc)
1754     goto leave;
1755
1756   flush_cache (app);
1757
1758   rc = iso7816_put_data (app->slot,
1759                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1760                          template, template_len);
1761   if (rc)
1762     {
1763       log_error (_("failed to store the key: %s\n"), gpg_strerror (rc));
1764       rc = gpg_error (GPG_ERR_CARD);
1765       goto leave;
1766     }
1767  
1768 /*    log_printhex ("RSA n:", m, mlen);  */
1769 /*    log_printhex ("RSA e:", e, elen);  */
1770
1771   rc = store_fpr (app->slot, keyno, (u32)created_at,
1772                   m, mlen, e, elen, fprbuf, app->card_version);
1773
1774  leave:
1775   return rc;
1776 }
1777
1778
1779 /* Utility function for external tools: Read the public RSA key at
1780    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1781 int 
1782 app_openpgp_readkey (app_t app, int keyno, unsigned char **m, size_t *mlen,
1783                      unsigned char **e, size_t *elen)
1784 {
1785   int rc;
1786   const unsigned char *keydata, *a;
1787   unsigned char *buffer;
1788   size_t buflen, keydatalen, alen;
1789
1790   *m = NULL;
1791   *e = NULL;
1792
1793   if (keyno < 1 || keyno > 3)
1794     return gpg_error (GPG_ERR_INV_ID);
1795   keyno--;
1796
1797   rc = iso7816_read_public_key(app->slot, 
1798                                keyno == 0? "\xB6" :
1799                                keyno == 1? "\xB8" : "\xA4",
1800                                2,
1801                                &buffer, &buflen);
1802   if (rc)
1803     {
1804       rc = gpg_error (GPG_ERR_CARD);
1805       log_error (_("reading the key failed\n"));
1806       goto leave;
1807     }
1808
1809   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1810   if (!keydata)
1811     {
1812       log_error (_("response does not contain the public key data\n"));
1813       rc = gpg_error (GPG_ERR_CARD);
1814       goto leave;
1815     }
1816  
1817   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
1818   if (!a)
1819     {
1820       log_error (_("response does not contain the RSA modulus\n"));
1821       rc = gpg_error (GPG_ERR_CARD);
1822       goto leave;
1823     }
1824   *mlen = alen;
1825   *m = xmalloc (alen);
1826   memcpy (*m, a, alen);
1827   
1828   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
1829   if (!a)
1830     {
1831       log_error (_("response does not contain the RSA public exponent\n"));
1832       rc = gpg_error (GPG_ERR_CARD);
1833       goto leave;
1834     }
1835   *elen = alen;
1836   *e = xmalloc (alen);
1837   memcpy (*e, a, alen);
1838
1839  leave:
1840   xfree (buffer);
1841   if (rc)
1842     { 
1843       xfree (*m); *m = NULL;
1844       xfree (*e); *e = NULL;
1845     }
1846   return rc;
1847 }