Updated FSF's address.
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003, 2004, 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  *
21  * $Id$
22  */
23
24 #include <config.h>
25 #include <errno.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <assert.h>
30 #include <time.h>
31
32 #if GNUPG_MAJOR_VERSION == 1
33 /* This is used with GnuPG version < 1.9.  The code has been source
34    copied from the current GnuPG >= 1.9  and is maintained over
35    there. */
36 #include "options.h"
37 #include "errors.h"
38 #include "memory.h"
39 #include "util.h"
40 #include "cardglue.h"
41 #else /* GNUPG_MAJOR_VERSION != 1 */
42 #include "scdaemon.h"
43 #endif /* GNUPG_MAJOR_VERSION != 1 */
44
45 #include "i18n.h"
46 #include "iso7816.h"
47 #include "app-common.h"
48 #include "tlv.h"
49
50
51 static struct {
52   int tag;
53   int constructed;
54   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
55   int binary;
56   int dont_cache;
57   int flush_on_error;
58   int get_immediate_in_v11; /* Enable a hack to bypass the cache of
59                                this data object if it is used in 1.1
60                                and later versions of the card.  This
61                                does not work with composite DO and is
62                                currently only useful for the CHV
63                                status bytes. */
64   char *desc;
65 } data_objects[] = {
66   { 0x005E, 0,    0, 1, 0, 0, 0, "Login Data" },
67   { 0x5F50, 0,    0, 0, 0, 0, 0, "URL" },
68   { 0x0065, 1,    0, 1, 0, 0, 0, "Cardholder Related Data"},
69   { 0x005B, 0, 0x65, 0, 0, 0, 0, "Name" },
70   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, "Language preferences" },
71   { 0x5F35, 0, 0x65, 0, 0, 0, 0, "Sex" },
72   { 0x006E, 1,    0, 1, 0, 0, 0, "Application Related Data" },
73   { 0x004F, 0, 0x6E, 1, 0, 0, 0, "AID" },
74   { 0x0073, 1,    0, 1, 0, 0, 0, "Discretionary Data Objects" },
75   { 0x0047, 0, 0x6E, 1, 1, 0, 0, "Card Capabilities" },
76   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, "Extended Card Capabilities" },
77   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Signature" },
78   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Decryption" },
79   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Authentication" },
80   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, "CHV Status Bytes" },
81   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, "Fingerprints" },
82   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, "CA Fingerprints" },
83   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, "Generation time" },
84   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
85   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
86   { 0x0101, 0,    0, 0, 0, 0, 0, "Private DO 1"},
87   { 0x0102, 0,    0, 0, 0, 0, 0, "Private DO 2"},
88   { 0x0103, 0,    0, 0, 0, 0, 0, "Private DO 3"},
89   { 0x0104, 0,    0, 0, 0, 0, 0, "Private DO 4"},
90   { 0 }
91 };
92
93
94 /* One cache item for DOs.  */
95 struct cache_s {
96   struct cache_s *next;
97   int tag;
98   size_t length;
99   unsigned char data[1];
100 };
101
102
103 /* Object with application (i.e. OpenPGP card) specific data.  */
104 struct app_local_s {
105   /* A linked list with cached DOs.  */
106   struct cache_s *cache;
107   
108   /* Keep track of the public keys.  */
109   struct
110   {
111     int read_done;   /* True if we have at least tried to read them.  */
112     unsigned char *key; /* This is a malloced buffer with a canonical
113                            encoded S-expression encoding a public
114                            key. Might be NULL if key is not
115                            available.  */
116     size_t keylen;      /* The length of the above S-expression.  This
117                            is usullay only required for cross checks
118                            because the length of an S-expression is
119                            implicitly available.  */
120   } pk[3];
121
122   /* Keep track of card capabilities.  */
123   struct 
124   {
125     unsigned int get_challenge:1;
126     unsigned int key_import:1;
127     unsigned int change_force_chv:1;
128     unsigned int private_dos:1;
129   } extcap;
130
131   /* Flags used to control the application.  */
132   struct
133   {
134     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
135     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
136   } flags;
137 };
138
139
140
141 /***** Local prototypes  *****/
142 static unsigned long convert_sig_counter_value (const unsigned char *value,
143                                                 size_t valuelen);
144 static unsigned long get_sig_counter (app_t app);
145
146
147
148
149 \f
150 /* Deconstructor. */
151 static void
152 do_deinit (app_t app)
153 {
154   if (app && app->app_local)
155     {
156       struct cache_s *c, *c2;
157       int i;
158
159       for (c = app->app_local->cache; c; c = c2)
160         {
161           c2 = c->next;
162           xfree (c);
163         }
164
165       for (i=0; i < DIM (app->app_local->pk); i++)
166         {
167           xfree (app->app_local->pk[i].key);
168           app->app_local->pk[i].read_done = 0;
169         }
170       xfree (app->app_local);
171       app->app_local = NULL;
172     }
173 }
174
175
176 /* Wrapper around iso7816_get_data which first tries to get the data
177    from the cache.  With GET_IMMEDIATE passed as true, the cache is
178    bypassed. */
179 static gpg_error_t
180 get_cached_data (app_t app, int tag, 
181                  unsigned char **result, size_t *resultlen,
182                  int get_immediate)
183 {
184   gpg_error_t err;
185   int i;
186   unsigned char *p;
187   size_t len;
188   struct cache_s *c;
189
190   *result = NULL;
191   *resultlen = 0;
192
193   if (!get_immediate)
194     {
195       for (c=app->app_local->cache; c; c = c->next)
196         if (c->tag == tag)
197           {
198             if(c->length)
199               {
200                 p = xtrymalloc (c->length);
201                 if (!p)
202                   return gpg_error (gpg_err_code_from_errno (errno));
203                 memcpy (p, c->data, c->length);
204                 *result = p;
205               }
206             
207             *resultlen = c->length;
208             
209             return 0;
210           }
211     }
212   
213   err = iso7816_get_data (app->slot, tag, &p, &len);
214   if (err)
215     return err;
216   *result = p;
217   *resultlen = len;
218
219   /* Check whether we should cache this object. */
220   if (get_immediate)
221     return 0;
222
223   for (i=0; data_objects[i].tag; i++)
224     if (data_objects[i].tag == tag)
225       {
226         if (data_objects[i].dont_cache)
227           return 0;
228         break;
229       }
230
231   /* Okay, cache it. */
232   for (c=app->app_local->cache; c; c = c->next)
233     assert (c->tag != tag);
234   
235   c = xtrymalloc (sizeof *c + len);
236   if (c)
237     {
238       memcpy (c->data, p, len);
239       c->length = len;
240       c->tag = tag;
241       c->next = app->app_local->cache;
242       app->app_local->cache = c;
243     }
244
245   return 0;
246 }
247
248 /* Remove DO at TAG from the cache. */
249 static void
250 flush_cache_item (app_t app, int tag)
251 {
252   struct cache_s *c, *cprev;
253   int i;
254
255   if (!app->app_local)
256     return;
257
258   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
259     if (c->tag == tag)
260       {
261         if (cprev)
262           cprev->next = c->next;
263         else
264           app->app_local->cache = c->next;
265         xfree (c);
266
267         for (c=app->app_local->cache; c ; c = c->next)
268           {
269             assert (c->tag != tag); /* Oops: duplicated entry. */
270           }
271         return;
272       }
273
274   /* Try again if we have an outer tag. */
275   for (i=0; data_objects[i].tag; i++)
276     if (data_objects[i].tag == tag && data_objects[i].get_from
277         && data_objects[i].get_from != tag)
278       flush_cache_item (app, data_objects[i].get_from);
279 }
280
281 /* Flush all entries from the cache which might be out of sync after
282    an error. */
283 static void
284 flush_cache_after_error (app_t app)
285 {
286   int i;
287
288   for (i=0; data_objects[i].tag; i++)
289     if (data_objects[i].flush_on_error)
290       flush_cache_item (app, data_objects[i].tag);
291 }
292
293
294 /* Flush the entire cache. */
295 static void
296 flush_cache (app_t app)
297 {
298   if (app && app->app_local)
299     {
300       struct cache_s *c, *c2;
301
302       for (c = app->app_local->cache; c; c = c2)
303         {
304           c2 = c->next;
305           xfree (c);
306         }
307       app->app_local->cache = NULL;
308     }
309 }
310
311
312 /* Get the DO identified by TAG from the card in SLOT and return a
313    buffer with its content in RESULT and NBYTES.  The return value is
314    NULL if not found or a pointer which must be used to release the
315    buffer holding value. */
316 static void *
317 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
318             int *r_rc)
319 {
320   int rc, i;
321   unsigned char *buffer;
322   size_t buflen;
323   unsigned char *value;
324   size_t valuelen;
325   int dummyrc;
326
327   if (!r_rc)
328     r_rc = &dummyrc;
329
330   *result = NULL;
331   *nbytes = 0;
332   *r_rc = 0;
333   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
334     ;
335
336   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
337     {
338       rc = iso7816_get_data (app->slot, tag, &buffer, &buflen);
339       if (rc)
340         {
341           *r_rc = rc;
342           return NULL;
343         }
344       *result = buffer;
345       *nbytes = buflen;
346       return buffer;
347     }
348
349   value = NULL;
350   rc = -1;
351   if (data_objects[i].tag && data_objects[i].get_from)
352     {
353       rc = get_cached_data (app, data_objects[i].get_from,
354                             &buffer, &buflen,
355                             (data_objects[i].dont_cache 
356                              || data_objects[i].get_immediate_in_v11));
357       if (!rc)
358         {
359           const unsigned char *s;
360
361           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
362           if (!s)
363             value = NULL; /* not found */
364           else if (valuelen > buflen - (s - buffer))
365             {
366               log_error ("warning: constructed DO too short\n");
367               value = NULL;
368               xfree (buffer); buffer = NULL;
369             }
370           else
371             value = buffer + (s - buffer);
372         }
373     }
374
375   if (!value) /* Not in a constructed DO, try simple. */
376     {
377       rc = get_cached_data (app, tag, &buffer, &buflen,
378                             (data_objects[i].dont_cache 
379                              || data_objects[i].get_immediate_in_v11));
380       if (!rc)
381         {
382           value = buffer;
383           valuelen = buflen;
384         }
385     }
386
387   if (!rc)
388     {
389       *nbytes = valuelen;
390       *result = value;
391       return buffer;
392     }
393   *r_rc = rc;
394   return NULL;
395 }
396
397
398 static void
399 dump_all_do (int slot)
400 {
401   int rc, i, j;
402   unsigned char *buffer;
403   size_t buflen;
404   
405   for (i=0; data_objects[i].tag; i++)
406     {
407       if (data_objects[i].get_from)
408         continue;
409
410       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
411       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
412         ;
413       else if (rc) 
414         log_info ("DO `%s' not available: %s\n",
415                   data_objects[i].desc, gpg_strerror (rc));
416       else
417         {
418           if (data_objects[i].binary)
419             {
420               log_info ("DO `%s': ", data_objects[i].desc);
421               log_printhex ("", buffer, buflen);
422             }
423           else
424             log_info ("DO `%s': `%.*s'\n",
425                       data_objects[i].desc,
426                       (int)buflen, buffer); /* FIXME: sanitize */
427
428           if (data_objects[i].constructed)
429             {
430               for (j=0; data_objects[j].tag; j++)
431                 {
432                   const unsigned char *value;
433                   size_t valuelen;
434                   
435                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
436                     continue;
437                   value = find_tlv_unchecked (buffer, buflen,
438                                               data_objects[j].tag, &valuelen);
439                   if (!value)
440                     ; /* not found */
441                   else if (valuelen > buflen - (value - buffer))
442                     log_error ("warning: constructed DO too short\n");
443                   else
444                     {
445                       if (data_objects[j].binary)
446                         {
447                           log_info ("DO `%s': ", data_objects[j].desc);
448                           log_printhex ("", value, valuelen);
449                         }
450                       else
451                         log_info ("DO `%s': `%.*s'\n",
452                                   data_objects[j].desc,
453                                   (int)valuelen, value); /* FIXME: sanitize */
454                     }
455                 }
456             }
457         }
458       xfree (buffer); buffer = NULL;
459     }
460 }
461
462
463 /* Count the number of bits, assuming the A represents an unsigned big
464    integer of length LEN bytes. */
465 static unsigned int
466 count_bits (const unsigned char *a, size_t len)
467 {
468   unsigned int n = len * 8;
469   int i;
470
471   for (; len && !*a; len--, a++, n -=8)
472     ;
473   if (len)
474     {
475       for (i=7; i && !(*a & (1<<i)); i--)
476         n--;
477     }
478   return n;
479 }
480
481 /* GnuPG makes special use of the login-data DO, this fucntion parses
482    the login data to store the flags for later use.  It may be called
483    at any time and should be called after changing the login-data DO.
484
485    Everything up to a LF is considered a mailbox or account name.  If
486    the first LF is followed by DC4 (0x14) control sequence are
487    expected up to the next LF.  Control sequences are separated by FS
488    (0x18) and consist of key=value pairs.  There is one key defined:
489
490     F=<flags>
491
492     Were FLAGS is a plain hexadecimal number representing flag values.
493     The lsb is here the rightmost bit.  Defined flags bits are:
494
495       Bit 0 = CHV1 and CHV2 are not syncronized
496       Bit 1 = CHV2 has been been set to the default PIN of "123456"
497               (this implies that bit 0 is also set).
498
499 */
500 static void
501 parse_login_data (app_t app)
502 {
503   unsigned char *buffer, *p;
504   size_t buflen, len;
505   void *relptr;
506
507   /* Set defaults.  */
508   app->app_local->flags.no_sync = 0;
509   app->app_local->flags.def_chv2 = 0;
510
511   /* Read the DO.  */
512   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
513   if (!relptr)
514     return; /* Ooops. */
515   for (; buflen; buflen--, buffer++)
516     if (*buffer == '\n')
517       break;
518   if (buflen < 2 || buffer[1] != '\x14')
519     return; /* No control sequences.  */
520   buflen--;
521   buffer++;
522   do
523     {
524       buflen--;
525       buffer++;
526       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
527         {
528           /* Flags control sequence found.  */
529           int lastdig = 0;
530
531           /* For now we are only interested in the last digit, so skip
532              any leading digits but bail out on invalid characters. */
533           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
534             lastdig = xtoi_1 (p);
535           if (len && !(*p == '\n' || *p == '\x18'))
536             goto next;  /* Invalid characters in field.  */
537           app->app_local->flags.no_sync = !!(lastdig & 1);
538           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
539         }
540     next:
541       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
542         if (*buffer == '\n')
543           buflen = 1; 
544     }
545   while (buflen);
546
547   xfree (relptr);
548 }
549
550 /* Note, that FPR must be at least 20 bytes. */
551 static gpg_error_t 
552 store_fpr (int slot, int keynumber, u32 timestamp,
553            const unsigned char *m, size_t mlen,
554            const unsigned char *e, size_t elen, 
555            unsigned char *fpr, unsigned int card_version)
556 {
557   unsigned int n, nbits;
558   unsigned char *buffer, *p;
559   int rc;
560   
561   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
562     ;
563   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
564     ;
565
566   n = 6 + 2 + mlen + 2 + elen;
567   p = buffer = xtrymalloc (3 + n);
568   if (!buffer)
569     return gpg_error_from_errno (errno);
570   
571   *p++ = 0x99;     /* ctb */
572   *p++ = n >> 8;   /* 2 byte length header */
573   *p++ = n;
574   *p++ = 4;        /* key packet version */
575   *p++ = timestamp >> 24;
576   *p++ = timestamp >> 16;
577   *p++ = timestamp >>  8;
578   *p++ = timestamp;
579   *p++ = 1; /* RSA */
580   nbits = count_bits (m, mlen);
581   *p++ = nbits >> 8;
582   *p++ = nbits;
583   memcpy (p, m, mlen); p += mlen;
584   nbits = count_bits (e, elen);
585   *p++ = nbits >> 8;
586   *p++ = nbits;
587   memcpy (p, e, elen); p += elen;
588     
589   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
590
591   xfree (buffer);
592
593   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
594                                + keynumber, fpr, 20);
595   if (rc)
596     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
597
598   if (!rc && card_version > 0x0100)
599     {
600       unsigned char buf[4];
601
602       buf[0] = timestamp >> 24;
603       buf[1] = timestamp >> 16;
604       buf[2] = timestamp >>  8;
605       buf[3] = timestamp;
606
607       rc = iso7816_put_data (slot, 0xCE + keynumber, buf, 4);
608       if (rc)
609         log_error (_("failed to store the creation date: %s\n"),
610                    gpg_strerror (rc));
611     }
612
613   return rc;
614 }
615
616        
617 static void
618 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
619                       int number, const unsigned char *fpr)
620 {                      
621   int i;
622   char buf[41];
623   char numbuf[25];
624
625   for (i=0; i < 20 && !fpr[i]; i++)
626     ;
627   if (i==20)
628     return; /* All zero. */
629   for (i=0; i< 20; i++)
630     sprintf (buf+2*i, "%02X", fpr[i]);
631   if (number == -1)
632     *numbuf = 0; /* Don't print the key number */
633   else
634     sprintf (numbuf, "%d", number);
635   send_status_info (ctrl, keyword,
636                     numbuf, (size_t)strlen(numbuf),
637                     buf, (size_t)strlen (buf), NULL, 0);
638 }
639
640 static void
641 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
642                           int number, const unsigned char *stamp)
643 {                      
644   char numbuf1[50], numbuf2[50];
645   unsigned long value;
646
647   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
648   if (!value)
649     return;
650   sprintf (numbuf1, "%d", number);
651   sprintf (numbuf2, "%lu", value);
652   send_status_info (ctrl, keyword,
653                     numbuf1, (size_t)strlen(numbuf1),
654                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
655 }
656
657 static void
658 send_key_data (ctrl_t ctrl, const char *name, 
659                const unsigned char *a, size_t alen)
660 {
661   char *p, *buf = xmalloc (alen*2+1);
662   
663   for (p=buf; alen; a++, alen--, p += 2)
664     sprintf (p, "%02X", *a);
665
666   send_status_info (ctrl, "KEY-DATA",
667                     name, (size_t)strlen(name), 
668                     buf, (size_t)strlen (buf),
669                     NULL, 0);
670   xfree (buf);
671 }
672
673 /* Implement the GETATTR command.  This is similar to the LEARN
674    command but returns just one value via the status interface. */
675 static gpg_error_t 
676 do_getattr (app_t app, ctrl_t ctrl, const char *name)
677 {
678   static struct {
679     const char *name;
680     int tag;
681     int special;
682   } table[] = {
683     { "DISP-NAME",    0x005B },
684     { "LOGIN-DATA",   0x005E },
685     { "DISP-LANG",    0x5F2D },
686     { "DISP-SEX",     0x5F35 },
687     { "PUBKEY-URL",   0x5F50 },
688     { "KEY-FPR",      0x00C5, 3 },
689     { "KEY-TIME",     0x00CD, 4 },
690     { "CA-FPR",       0x00C6, 3 },
691     { "CHV-STATUS",   0x00C4, 1 }, 
692     { "SIG-COUNTER",  0x0093, 2 },
693     { "SERIALNO",     0x004F, -1 },
694     { "AID",          0x004F },
695     { "EXTCAP",       0x0000, -2 },
696     { "PRIVATE-DO-1", 0x0101 },
697     { "PRIVATE-DO-2", 0x0102 },
698     { "PRIVATE-DO-3", 0x0103 },
699     { "PRIVATE-DO-4", 0x0104 },
700     { "$AUTHKEYID",   0x0000, -3 },
701     { "$DISPSERIALNO",0x0000, -4 },
702     { NULL, 0 }
703   };
704   int idx, i, rc;
705   void *relptr;
706   unsigned char *value;
707   size_t valuelen;
708
709   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
710     ;
711   if (!table[idx].name)
712     return gpg_error (GPG_ERR_INV_NAME); 
713   
714   if (table[idx].special == -1)
715     {
716       /* The serial number is very special.  We could have used the
717          AID DO to retrieve it, but we have it already in the app
718          context and the stamp argument is required anyway which we
719          can't by other means. The AID DO is available anyway but not
720          hex formatted. */
721       char *serial;
722       time_t stamp;
723       char tmp[50];
724
725       if (!app_get_serial_and_stamp (app, &serial, &stamp))
726         {
727           sprintf (tmp, "%lu", (unsigned long)stamp);
728           send_status_info (ctrl, "SERIALNO",
729                             serial, strlen (serial),
730                             tmp, strlen (tmp),
731                             NULL, 0);
732           xfree (serial);
733         }
734       return 0;
735     }
736   if (table[idx].special == -2)
737     {
738       char tmp[50];
739
740       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d", 
741                app->app_local->extcap.get_challenge,
742                app->app_local->extcap.key_import,
743                app->app_local->extcap.change_force_chv,
744                app->app_local->extcap.private_dos);
745       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
746       return 0;
747     }
748   if (table[idx].special == -3)
749     {
750       char const tmp[] = "OPENPGP.3";
751       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
752       return 0;
753     }
754   if (table[idx].special == -4)
755     {
756       char *serial;
757       time_t stamp;
758     
759       if (!app_get_serial_and_stamp (app, &serial, &stamp))
760         {
761           if (strlen (serial) > 16+12)
762             {
763               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
764               xfree (serial);
765               return 0;
766             }
767           xfree (serial);
768         }
769       return gpg_error (GPG_ERR_INV_NAME); 
770     }
771
772   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
773   if (relptr)
774     {
775       if (table[idx].special == 1)
776         {
777           char numbuf[7*23];
778           
779           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
780             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
781           send_status_info (ctrl, table[idx].name,
782                             numbuf, strlen (numbuf), NULL, 0);
783         }
784       else if (table[idx].special == 2)
785         {
786           char numbuf[50];
787
788           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
789           send_status_info (ctrl, table[idx].name,
790                             numbuf, strlen (numbuf), NULL, 0);
791         }
792       else if (table[idx].special == 3)
793         {
794           if (valuelen >= 60)
795             for (i=0; i < 3; i++)
796               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
797         }
798       else if (table[idx].special == 4)
799         {
800           if (valuelen >= 12)
801             for (i=0; i < 3; i++)
802               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
803         }
804       else
805         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
806
807       xfree (relptr);
808     }
809   return rc;
810 }
811
812 /* Retrieve the fingerprint from the card inserted in SLOT and write
813    the according hex representation to FPR.  Caller must have provide
814    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
815    error code. */
816 #if GNUPG_MAJOR_VERSION > 1
817 static gpg_error_t
818 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
819 {
820   gpg_error_t err = 0;
821   void *relptr;
822   unsigned char *value;
823   size_t valuelen;
824   int i;
825
826   assert (keyno >=0 && keyno <= 2);
827
828   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
829   if (relptr && valuelen >= 60)
830     {
831       for (i = 0; i < 20; i++)
832         sprintf (fpr + (i * 2), "%02X", value[(keyno*20)+i]);
833     }
834   else
835     err = gpg_error (GPG_ERR_NOT_FOUND);
836   xfree (relptr);
837   return err;
838 }
839 #endif /*GNUPG_MAJOR_VERSION > 1*/
840
841
842 /* Retrieve the public key material for the RSA key, whose fingerprint
843    is FPR, from gpg output, which can be read through the stream FP.
844    The RSA modulus will be stored at the address of M and MLEN, the
845    public exponent at E and ELEN.  Returns zero on success, an error
846    code on failure.  Caller must release the allocated buffers at M
847    and E if the function returns success.  */
848 #if GNUPG_MAJOR_VERSION > 1
849 static gpg_error_t
850 retrieve_key_material (FILE *fp, const char *hexkeyid,
851                        const unsigned char **m, size_t *mlen,
852                        const unsigned char **e, size_t *elen)
853 {
854   gcry_error_t err = 0;
855   char *line = NULL;    /* read_line() buffer. */
856   size_t line_size = 0; /* Helper for for read_line. */
857   int found_key = 0;    /* Helper to find a matching key. */
858   unsigned char *m_new = NULL;
859   unsigned char *e_new = NULL;
860   size_t m_new_n = 0;
861   size_t e_new_n = 0;
862
863   /* Loop over all records until we have found the subkey
864      corresponsing to the fingerprint. Inm general the first record
865      should be the pub record, but we don't rely on that.  Given that
866      we only need to look at one key, it is sufficient to compare the
867      keyid so that we don't need to look at "fpr" records. */
868   for (;;)
869     {
870       char *p;
871       char *fields[6];
872       int nfields;
873       size_t max_length;
874       gcry_mpi_t mpi;
875       int i;
876
877       max_length = 4096;
878       i = read_line (fp, &line, &line_size, &max_length);
879       if (!i)
880         break; /* EOF. */
881       if (i < 0)
882         {
883           err = gpg_error_from_errno (errno);
884           goto leave; /* Error. */
885         }
886       if (!max_length)
887         {
888           err = gpg_error (GPG_ERR_TRUNCATED);
889           goto leave;  /* Line truncated - we better stop processing.  */
890         }
891
892       /* Parse the line into fields. */
893       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
894         {
895           fields[nfields] = p;
896           p = strchr (p, ':');
897           if (p)
898             *(p++) = 0;
899         }
900       if (!nfields)
901         continue; /* No fields at all - skip line.  */
902
903       if (!found_key)
904         {
905           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
906                && nfields > 4 && !strcmp (fields[4], hexkeyid))
907             found_key = 1;
908           continue;
909         }
910       
911       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
912         break; /* Next key - stop.  */
913
914       if ( strcmp (fields[0], "pkd") )
915         continue; /* Not a key data record.  */
916       i = 0; /* Avoid erroneous compiler warning. */
917       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
918            || (!i && m_new) || (i && e_new))
919         {
920           err = gpg_error (GPG_ERR_GENERAL);
921           goto leave; /* Error: Invalid key data record or not an RSA key.  */
922         }
923       
924       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
925       if (err)
926         mpi = NULL;
927       else if (!i)
928         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
929       else
930         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
931       gcry_mpi_release (mpi);
932       if (err)
933         goto leave;
934     }
935   
936   if (m_new && e_new)
937     {
938       *m = m_new;
939       *mlen = m_new_n;
940       m_new = NULL;
941       *e = e_new;
942       *elen = e_new_n;
943       e_new = NULL;
944     }
945   else
946     err = gpg_error (GPG_ERR_GENERAL);
947
948  leave:
949   xfree (m_new);
950   xfree (e_new);
951   xfree (line);
952   return err;
953 }
954 #endif /*GNUPG_MAJOR_VERSION > 1*/
955
956
957 /* Get the public key for KEYNO and store it as an S-expresion with
958    the APP handle.  On error that field gets cleared.  If we already
959    know about the public key we will just return.  Note that this does
960    not mean a key is available; this is soley indicated by the
961    presence of the app->app_local->pk[KEYNO-1].key field.
962
963    Note that GnuPG 1.x does not need this and it would be too time
964    consuming to send it just for the fun of it. However, given that we
965    use the same code in gpg 1.4, we can't use the gcry S-expresion
966    here but need to open encode it. */
967 #if GNUPG_MAJOR_VERSION > 1
968 static gpg_error_t
969 get_public_key (app_t app, int keyno)
970 {
971   gpg_error_t err = 0;
972   unsigned char *buffer;
973   const unsigned char *keydata, *m, *e;
974   size_t buflen, keydatalen, mlen, elen;
975   unsigned char *mbuf = NULL;
976   unsigned char *ebuf = NULL;
977   char *keybuf = NULL;
978   char *keybuf_p;
979
980   if (keyno < 1 || keyno > 3)
981     return gpg_error (GPG_ERR_INV_ID);
982   keyno--;
983
984   /* Already cached? */
985   if (app->app_local->pk[keyno].read_done)
986     return 0;
987
988   xfree (app->app_local->pk[keyno].key);
989   app->app_local->pk[keyno].key = NULL;
990   app->app_local->pk[keyno].keylen = 0;
991
992   m = e = NULL; /* (avoid cc warning) */
993
994   if (app->card_version > 0x0100)
995     {
996       /* We may simply read the public key out of these cards.  */
997       err = iso7816_read_public_key 
998         (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
999                                            keyno == 1? "\xB8" : "\xA4"),
1000          2,  
1001          &buffer, &buflen);
1002       if (err)
1003         {
1004           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1005           goto leave;
1006         }
1007
1008       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1009       if (!keydata)
1010         {
1011           err = gpg_error (GPG_ERR_CARD);
1012           log_error (_("response does not contain the public key data\n"));
1013           goto leave;
1014         }
1015  
1016       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1017       if (!m)
1018         {
1019           err = gpg_error (GPG_ERR_CARD);
1020           log_error (_("response does not contain the RSA modulus\n"));
1021           goto leave;
1022         }
1023       
1024
1025       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1026       if (!e)
1027         {
1028           err = gpg_error (GPG_ERR_CARD);
1029           log_error (_("response does not contain the RSA public exponent\n"));
1030           goto leave;
1031         }
1032
1033       /* Prepend numbers with a 0 if needed.  */
1034       if (mlen && (*m & 0x80))
1035         {
1036           mbuf = xtrymalloc ( mlen + 1);
1037           if (!mbuf)
1038             {
1039               err = gpg_error_from_errno (errno);
1040               goto leave;
1041             }
1042           *mbuf = 0;
1043           memcpy (mbuf+1, m, mlen);
1044           mlen++;
1045           m = mbuf;
1046         }
1047       if (elen && (*e & 0x80))
1048         {
1049           ebuf = xtrymalloc ( elen + 1);
1050           if (!ebuf)
1051             {
1052               err = gpg_error_from_errno (errno);
1053               goto leave;
1054             }
1055           *ebuf = 0;
1056           memcpy (ebuf+1, e, elen);
1057           elen++;
1058           e = ebuf;
1059         }
1060
1061     }
1062   else
1063     {
1064       /* Due to a design problem in v1.0 cards we can't get the public
1065          key out of these cards without doing a verify on CHV3.
1066          Clearly that is not an option and thus we try to locate the
1067          key using an external helper.
1068
1069          The helper we use here is gpg itself, which should know about
1070          the key in any case.  */
1071
1072       char fpr[41];
1073       char *hexkeyid;
1074       char *command = NULL;
1075       FILE *fp;
1076       int ret;
1077
1078       buffer = NULL; /* We don't need buffer.  */
1079
1080       err = retrieve_fpr_from_card (app, keyno, fpr);
1081       if (err)
1082         {
1083           log_error ("error while retrieving fpr from card: %s\n",
1084                      gpg_strerror (err));
1085           goto leave;
1086         }
1087       hexkeyid = fpr + 24;
1088
1089       ret = asprintf (&command,
1090                       "gpg --list-keys --with-colons --with-key-data '%s'",
1091                       fpr);
1092       if (ret < 0)
1093         {
1094           err = gpg_error_from_errno (errno);
1095           goto leave;
1096         }
1097
1098       fp = popen (command, "r");
1099       free (command);
1100       if (!fp)
1101         {
1102           err = gpg_error_from_errno (errno);
1103           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1104           goto leave;
1105         }
1106
1107       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1108       fclose (fp);
1109       if (err)
1110         {
1111           log_error ("error while retrieving key material through pipe: %s\n",
1112                      gpg_strerror (err));
1113           goto leave;
1114         }
1115     }
1116
1117   /* Allocate a buffer to construct the S-expression.  */
1118   /* FIXME: We should provide a generalized S-expression creation
1119      mechanism. */
1120   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1121   if (!keybuf)
1122     {
1123       err = gpg_error_from_errno (errno);
1124       goto leave;
1125     }
1126   
1127   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1128   keybuf_p = keybuf + strlen (keybuf);
1129   memcpy (keybuf_p, m, mlen);
1130   keybuf_p += mlen;
1131   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1132   keybuf_p += strlen (keybuf_p);
1133   memcpy (keybuf_p, e, elen);
1134   keybuf_p += elen;
1135   strcpy (keybuf_p, ")))");
1136   keybuf_p += strlen (keybuf_p);
1137   
1138   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1139   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1140
1141  leave:
1142   /* Set a flag to indicate that we tried to read the key.  */
1143   app->app_local->pk[keyno].read_done = 1;
1144
1145   xfree (buffer);
1146   xfree (mbuf);
1147   xfree (ebuf);
1148   return 0;
1149 }
1150 #endif /* GNUPG_MAJOR_VERSION > 1 */
1151
1152
1153
1154 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1155    This is used by the LEARN command. */
1156 static gpg_error_t
1157 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1158 {
1159   gpg_error_t err = 0;
1160   /* Note that GnuPG 1.x does not need this and it would be too time
1161      consuming to send it just for the fun of it. */
1162 #if GNUPG_MAJOR_VERSION > 1
1163   unsigned char grip[20];
1164   char gripstr[41];
1165   char idbuf[50];
1166   int i;
1167
1168   err = get_public_key (app, keyno);
1169   if (err)
1170     goto leave;
1171   
1172   assert (keyno >= 1 && keyno <= 3);
1173   if (!app->app_local->pk[keyno-1].key)
1174     goto leave; /* No such key - ignore. */
1175
1176   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1177                                  app->app_local->pk[keyno-1].keylen,
1178                                  grip);
1179   if (err)
1180     goto leave;
1181   
1182   for (i=0; i < 20; i++)
1183     sprintf (gripstr+i*2, "%02X", grip[i]);
1184
1185   sprintf (idbuf, "OPENPGP.%d", keyno);
1186   send_status_info (ctrl, "KEYPAIRINFO", 
1187                     gripstr, 40, 
1188                     idbuf, strlen (idbuf), 
1189                     NULL, (size_t)0);
1190
1191  leave:
1192 #endif /* GNUPG_MAJOR_VERSION > 1 */
1193
1194   return err; 
1195 }
1196
1197
1198 /* Handle the LEARN command for OpenPGP.  */
1199 static gpg_error_t
1200 do_learn_status (app_t app, ctrl_t ctrl)
1201 {
1202   do_getattr (app, ctrl, "EXTCAP");
1203   do_getattr (app, ctrl, "DISP-NAME");
1204   do_getattr (app, ctrl, "DISP-LANG");
1205   do_getattr (app, ctrl, "DISP-SEX");
1206   do_getattr (app, ctrl, "PUBKEY-URL");
1207   do_getattr (app, ctrl, "LOGIN-DATA");
1208   do_getattr (app, ctrl, "KEY-FPR");
1209   if (app->card_version > 0x0100)
1210     do_getattr (app, ctrl, "KEY-TIME");
1211   do_getattr (app, ctrl, "CA-FPR");
1212   do_getattr (app, ctrl, "CHV-STATUS");
1213   do_getattr (app, ctrl, "SIG-COUNTER");
1214   if (app->app_local->extcap.private_dos)
1215     {
1216       do_getattr (app, ctrl, "PRIVATE-DO-1");
1217       do_getattr (app, ctrl, "PRIVATE-DO-2");
1218       if (app->did_chv2)
1219         do_getattr (app, ctrl, "PRIVATE-DO-3");
1220       if (app->did_chv3)
1221         do_getattr (app, ctrl, "PRIVATE-DO-4");
1222     }
1223   send_keypair_info (app, ctrl, 1);
1224   send_keypair_info (app, ctrl, 2);
1225   send_keypair_info (app, ctrl, 3);
1226   return 0;
1227 }
1228
1229
1230 /* Handle the READKEY command for OpenPGP.  On success a canonical
1231    encoded S-expression with the public key will get stored at PK and
1232    its length (for assertions) at PKLEN; the caller must release that
1233    buffer. On error PK and PKLEN are not changed and an error code is
1234    returned.  */
1235 static gpg_error_t
1236 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1237 {
1238 #if GNUPG_MAJOR_VERSION > 1
1239   gpg_error_t err;
1240   int keyno;
1241   unsigned char *buf;
1242
1243   if (!strcmp (keyid, "OPENPGP.1"))
1244     keyno = 1;
1245   else if (!strcmp (keyid, "OPENPGP.2"))
1246     keyno = 2;
1247   else if (!strcmp (keyid, "OPENPGP.3"))
1248     keyno = 3;
1249   else
1250     return gpg_error (GPG_ERR_INV_ID);
1251
1252   err = get_public_key (app, keyno);
1253   if (err)
1254     return err;
1255
1256   buf = app->app_local->pk[keyno-1].key;
1257   if (!buf)
1258     return gpg_error (GPG_ERR_NO_PUBKEY);
1259   *pklen = app->app_local->pk[keyno-1].keylen;;
1260   *pk = xtrymalloc (*pklen);
1261   if (!*pk)
1262     {
1263       err = gpg_error_from_errno (errno);
1264       *pklen = 0;
1265       return err;
1266     }
1267   memcpy (*pk, buf, *pklen);
1268   return 0;
1269 #else
1270   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1271 #endif
1272 }
1273
1274
1275
1276 /* Verify CHV2 if required.  Depending on the configuration of the
1277    card CHV1 will also be verified. */
1278 static gpg_error_t
1279 verify_chv2 (app_t app,
1280              gpg_error_t (*pincb)(void*, const char *, char **),
1281              void *pincb_arg)
1282 {
1283   int rc = 0;
1284
1285   if (!app->did_chv2) 
1286     {
1287       char *pinvalue;
1288       iso7816_pininfo_t pininfo;
1289
1290       memset (&pininfo, 0, sizeof pininfo);
1291       pininfo.mode = 1;
1292       pininfo.minlen = 6;
1293
1294       rc = pincb (pincb_arg, "PIN", &pinvalue); 
1295       if (rc)
1296         {
1297           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1298           return rc;
1299         }
1300
1301       if (strlen (pinvalue) < 6)
1302         {
1303           log_error (_("PIN for CHV%d is too short;"
1304                        " minimum length is %d\n"), 2, 6);
1305           xfree (pinvalue);
1306           return gpg_error (GPG_ERR_BAD_PIN);
1307         }
1308
1309       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1310       if (rc)
1311         {
1312           log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1313           xfree (pinvalue);
1314           flush_cache_after_error (app);
1315           return rc;
1316         }
1317       app->did_chv2 = 1;
1318
1319       if (!app->did_chv1 && !app->force_chv1)
1320         {
1321           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1322           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1323             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1324           if (rc)
1325             {
1326               log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1327               xfree (pinvalue);
1328               flush_cache_after_error (app);
1329               return rc;
1330             }
1331           app->did_chv1 = 1;
1332         }
1333       xfree (pinvalue);
1334     }
1335   return rc;
1336 }
1337
1338 /* Verify CHV3 if required. */
1339 static gpg_error_t
1340 verify_chv3 (app_t app,
1341              gpg_error_t (*pincb)(void*, const char *, char **),
1342              void *pincb_arg)
1343 {
1344   int rc = 0;
1345
1346 #if GNUPG_MAJOR_VERSION != 1
1347   if (!opt.allow_admin)
1348     {
1349       log_info (_("access to admin commands is not configured\n"));
1350       return gpg_error (GPG_ERR_EACCES);
1351     }
1352 #endif
1353       
1354   if (!app->did_chv3) 
1355     {
1356       char *pinvalue;
1357       void *relptr;
1358       unsigned char *value;
1359       size_t valuelen;
1360
1361       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1362       if (!relptr || valuelen < 7)
1363         {
1364           log_error (_("error retrieving CHV status from card\n"));
1365           xfree (relptr);
1366           return gpg_error (GPG_ERR_CARD);
1367         }
1368       if (value[6] == 0)
1369         {
1370           log_info (_("card is permanently locked!\n"));
1371           xfree (relptr);
1372           return gpg_error (GPG_ERR_BAD_PIN);
1373         }
1374
1375       log_info(_("%d Admin PIN attempts remaining before card"
1376                  " is permanently locked\n"), value[6]);
1377       xfree (relptr);
1378
1379       /* TRANSLATORS: Do not translate the "|A|" prefix but
1380          keep it at the start of the string.  We need this elsewhere
1381          to get some infos on the string. */
1382       rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1383       if (rc)
1384         {
1385           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1386           return rc;
1387         }
1388
1389       if (strlen (pinvalue) < 8)
1390         {
1391           log_error (_("PIN for CHV%d is too short;"
1392                        " minimum length is %d\n"), 3, 8);
1393           xfree (pinvalue);
1394           return gpg_error (GPG_ERR_BAD_PIN);
1395         }
1396
1397       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1398       xfree (pinvalue);
1399       if (rc)
1400         {
1401           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1402           flush_cache_after_error (app);
1403           return rc;
1404         }
1405       app->did_chv3 = 1;
1406     }
1407   return rc;
1408 }
1409
1410
1411 /* Handle the SETATTR operation. All arguments are already basically
1412    checked. */
1413 static gpg_error_t 
1414 do_setattr (app_t app, const char *name,
1415             gpg_error_t (*pincb)(void*, const char *, char **),
1416             void *pincb_arg,
1417             const unsigned char *value, size_t valuelen)
1418 {
1419   gpg_error_t rc;
1420   int idx;
1421   static struct {
1422     const char *name;
1423     int tag;
1424     int need_chv;
1425     int special;
1426   } table[] = {
1427     { "DISP-NAME",    0x005B, 3 },
1428     { "LOGIN-DATA",   0x005E, 3, 2 },
1429     { "DISP-LANG",    0x5F2D, 3 },
1430     { "DISP-SEX",     0x5F35, 3 },
1431     { "PUBKEY-URL",   0x5F50, 3 },
1432     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1433     { "CA-FPR-1",     0x00CA, 3 },
1434     { "CA-FPR-2",     0x00CB, 3 },
1435     { "CA-FPR-3",     0x00CC, 3 },
1436     { "PRIVATE-DO-1", 0x0101, 2 },
1437     { "PRIVATE-DO-2", 0x0102, 3 },
1438     { "PRIVATE-DO-3", 0x0103, 2 },
1439     { "PRIVATE-DO-4", 0x0104, 3 },
1440     { NULL, 0 }
1441   };
1442
1443
1444   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1445     ;
1446   if (!table[idx].name)
1447     return gpg_error (GPG_ERR_INV_NAME); 
1448
1449   switch (table[idx].need_chv)
1450     {
1451     case 2:
1452       rc = verify_chv2 (app, pincb, pincb_arg);
1453       break;
1454     case 3:
1455       rc = verify_chv3 (app, pincb, pincb_arg);
1456       break;
1457     default:
1458       rc = 0;
1459     }
1460   if (rc)
1461     return rc;
1462
1463   /* Flush the cache before writing it, so that the next get operation
1464      will reread the data from the card and thus get synced in case of
1465      errors (e.g. data truncated by the card). */
1466   flush_cache_item (app, table[idx].tag);
1467   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
1468   if (rc)
1469     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1470
1471   if (table[idx].special == 1)
1472     app->force_chv1 = (valuelen && *value == 0);
1473   else if (table[idx].special == 2)
1474     parse_login_data (app);
1475
1476   return rc;
1477 }
1478
1479
1480 /* Handle the PASSWD command. */
1481 static gpg_error_t 
1482 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, int reset_mode,
1483                gpg_error_t (*pincb)(void*, const char *, char **),
1484                void *pincb_arg)
1485 {
1486   int rc = 0;
1487   int chvno = atoi (chvnostr);
1488   char *pinvalue;
1489
1490   if (reset_mode && chvno == 3)
1491     {
1492       rc = gpg_error (GPG_ERR_INV_ID);
1493       goto leave;
1494     }
1495   else if (reset_mode || chvno == 3)
1496     {
1497       /* we always require that the PIN is entered. */
1498       app->did_chv3 = 0;
1499       rc = verify_chv3 (app, pincb, pincb_arg);
1500       if (rc)
1501         goto leave;
1502     }
1503   else if (chvno == 1 || chvno == 2)
1504     {
1505       /* CHV1 and CVH2 should always have the same value, thus we
1506          enforce it here.  */
1507       int save_force = app->force_chv1;
1508
1509       app->force_chv1 = 0;
1510       app->did_chv1 = 0;
1511       app->did_chv2 = 0;
1512       rc = verify_chv2 (app, pincb, pincb_arg);
1513       app->force_chv1 = save_force;
1514       if (rc)
1515         goto leave;
1516     }
1517   else
1518     {
1519       rc = gpg_error (GPG_ERR_INV_ID);
1520       goto leave;
1521     }
1522
1523   if (chvno == 3)
1524     app->did_chv3 = 0;
1525   else
1526     app->did_chv1 = app->did_chv2 = 0;
1527
1528   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1529      keep it at the start of the string.  We need this elsewhere
1530      to get some infos on the string. */
1531   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1532               &pinvalue); 
1533   if (rc)
1534     {
1535       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1536       goto leave;
1537     }
1538
1539   if (reset_mode)
1540     {
1541       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1542                                         pinvalue, strlen (pinvalue));
1543       if (!rc)
1544         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1545                                           pinvalue, strlen (pinvalue));
1546     }
1547   else
1548     {
1549       if (chvno == 1 || chvno == 2)
1550         {
1551           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1552                                               pinvalue, strlen (pinvalue));
1553           if (!rc)
1554             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1555                                                 pinvalue, strlen (pinvalue));
1556         }
1557       else
1558         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1559                                             pinvalue, strlen (pinvalue));
1560     }
1561   xfree (pinvalue);
1562   if (rc)
1563     flush_cache_after_error (app);
1564
1565  leave:
1566   return rc;
1567 }
1568
1569
1570 /* Check whether a key already exists.  KEYIDX is the index of the key
1571    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1572    error returned if the key already exists. */
1573 static gpg_error_t
1574 does_key_exist (app_t app, int keyidx, int force)
1575 {
1576   const unsigned char *fpr;
1577   unsigned char *buffer;
1578   size_t buflen, n;
1579   int i;
1580
1581   assert (keyidx >=0 && keyidx <= 2);
1582
1583   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1584     {
1585       log_error (_("error reading application data\n"));
1586       return gpg_error (GPG_ERR_GENERAL);
1587     }
1588   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1589   if (!fpr || n < 60)
1590     {
1591       log_error (_("error reading fingerprint DO\n"));
1592       xfree (buffer);
1593       return gpg_error (GPG_ERR_GENERAL);
1594     }
1595   fpr += 20*keyidx;
1596   for (i=0; i < 20 && !fpr[i]; i++)
1597     ;
1598   xfree (buffer);
1599   if (i!=20 && !force)
1600     {
1601       log_error (_("key already exists\n"));
1602       return gpg_error (GPG_ERR_EEXIST);
1603     }
1604   else if (i!=20)
1605     log_info (_("existing key will be replaced\n"));
1606   else
1607     log_info (_("generating new key\n"));
1608   return 0;
1609 }
1610
1611
1612
1613 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
1614    canonical encoded S-expression with the secret key in KEYDATA and
1615    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
1616    usual keyid which for OpenPGP is the string "OPENPGP.n" with
1617    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
1618    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
1619    the pinentry callback.  */
1620 static gpg_error_t
1621 do_writekey (app_t app, ctrl_t ctrl,
1622              const char *keyid, unsigned int flags,
1623              gpg_error_t (*pincb)(void*, const char *, char **),
1624              void *pincb_arg,
1625              const unsigned char *keydata, size_t keydatalen)
1626 {
1627   gpg_error_t err;
1628   int force = (flags & 1);
1629   int keyno;
1630   const unsigned char *buf, *tok;
1631   size_t buflen, toklen;
1632   int depth, last_depth1, last_depth2;
1633   const unsigned char *rsa_n = NULL;
1634   const unsigned char *rsa_e = NULL;
1635   const unsigned char *rsa_p = NULL;
1636   const unsigned char *rsa_q = NULL;
1637   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
1638   unsigned int nbits;
1639   unsigned char *template = NULL;
1640   unsigned char *tp;
1641   size_t template_len;
1642   unsigned char fprbuf[20];
1643   u32 created_at = 0;
1644
1645   if (!strcmp (keyid, "OPENPGP.1"))
1646     keyno = 0;
1647   else if (!strcmp (keyid, "OPENPGP.2"))
1648     keyno = 1;
1649   else if (!strcmp (keyid, "OPENPGP.3"))
1650     keyno = 2;
1651   else
1652     return gpg_error (GPG_ERR_INV_ID);
1653   
1654   err = does_key_exist (app, keyno, force);
1655   if (err)
1656     return err;
1657
1658
1659   /* 
1660      Parse the S-expression
1661    */
1662   buf = keydata;
1663   buflen = keydatalen;
1664   depth = 0;
1665   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1666     goto leave;
1667   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1668     goto leave;
1669   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
1670     {
1671       if (!tok)
1672         ;
1673       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
1674         log_info ("protected-private-key passed to writekey\n");
1675       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
1676         log_info ("shadowed-private-key passed to writekey\n");
1677       err = gpg_error (GPG_ERR_BAD_SECKEY);
1678       goto leave;
1679     }
1680   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1681     goto leave;
1682   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1683     goto leave;
1684   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
1685     {
1686       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
1687       goto leave;
1688     }
1689   last_depth1 = depth;
1690   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1691          && depth && depth >= last_depth1)
1692     {
1693       if (tok)
1694         {
1695           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1696           goto leave;
1697         }
1698       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1699         goto leave;
1700       if (tok && toklen == 1)
1701         {
1702           const unsigned char **mpi;
1703           size_t *mpi_len;
1704
1705           switch (*tok)
1706             {
1707             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
1708             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
1709             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
1710             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
1711             default: mpi = NULL;  mpi_len = NULL; break;
1712             }
1713           if (mpi && *mpi)
1714             {
1715               err = gpg_error (GPG_ERR_DUP_VALUE);
1716               goto leave;
1717             }
1718           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1719             goto leave;
1720           if (tok && mpi)
1721             {
1722               /* Strip off leading zero bytes and save. */
1723               for (;toklen && !*tok; toklen--, tok++)
1724                 ;
1725               *mpi = tok;
1726               *mpi_len = toklen;
1727             }
1728         }
1729       /* Skip until end of list. */
1730       last_depth2 = depth;
1731       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1732              && depth && depth >= last_depth2)
1733         ;
1734       if (err)
1735         goto leave;
1736     }
1737   /* Parse other attributes. */
1738   last_depth1 = depth;
1739   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1740          && depth && depth >= last_depth1)
1741     {
1742       if (tok)
1743         {
1744           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1745           goto leave;
1746         }
1747       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1748         goto leave;
1749       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
1750         {
1751           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
1752             goto leave;
1753           if (tok)
1754             {
1755               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
1756                    tok++, toklen--)
1757                 created_at = created_at*10 + (*tok - '0');
1758             }
1759         }
1760       /* Skip until end of list. */
1761       last_depth2 = depth;
1762       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1763              && depth && depth >= last_depth2)
1764         ;
1765       if (err)
1766         goto leave;
1767     }
1768
1769
1770   /* Check that we have all parameters and that they match the card
1771      description. */
1772   if (!created_at)
1773     {
1774       log_error (_("creation timestamp missing\n"));
1775       err = gpg_error (GPG_ERR_INV_VALUE);
1776       goto leave;
1777     }
1778   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
1779   if (nbits != 1024)
1780     {
1781       log_error (_("RSA modulus missing or not of size %d bits\n"), 1024);
1782       err = gpg_error (GPG_ERR_BAD_SECKEY);
1783       goto leave;
1784     }
1785   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
1786   if (nbits < 2 || nbits > 32)
1787     {
1788       log_error (_("RSA public exponent missing or larger than %d bits\n"),
1789                  32);
1790       err = gpg_error (GPG_ERR_BAD_SECKEY);
1791       goto leave;
1792     }
1793   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
1794   if (nbits != 512)
1795     {
1796       log_error (_("RSA prime %s missing or not of size %d bits\n"), "P", 512);
1797       err = gpg_error (GPG_ERR_BAD_SECKEY);
1798       goto leave;
1799     }
1800   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
1801   if (nbits != 512)
1802     {
1803       log_error (_("RSA prime %s missing or not of size %d bits\n"), "Q", 512);
1804       err = gpg_error (GPG_ERR_BAD_SECKEY);
1805       goto leave;
1806     }
1807   
1808
1809   /* Build the private key template as described in section 4.3.3.6 of
1810      the OpenPGP card specs:
1811          0xC0   <length> public exponent
1812          0xC1   <length> prime p 
1813          0xC2   <length> prime q 
1814   */
1815   assert (rsa_e_len <= 4);
1816   template_len = (1 + 1 + 4
1817                   + 1 + 1 + rsa_p_len
1818                   + 1 + 1 + rsa_q_len);
1819   template = tp = xtrymalloc_secure (template_len);
1820   if (!template)
1821     {
1822       err = gpg_error_from_errno (errno);
1823       goto leave;
1824     }
1825   *tp++ = 0xC0;
1826   *tp++ = 4;
1827   memcpy (tp, rsa_e, rsa_e_len);
1828   if (rsa_e_len < 4)
1829     {
1830       /* Right justify E. */
1831       memmove (tp+4-rsa_e_len, tp, 4-rsa_e_len);
1832       memset (tp, 0, 4-rsa_e_len);
1833     }                 
1834   tp += 4;
1835
1836   *tp++ = 0xC1;
1837   *tp++ = rsa_p_len;
1838   memcpy (tp, rsa_p, rsa_p_len);
1839   tp += rsa_p_len;
1840
1841   *tp++ = 0xC2;
1842   *tp++ = rsa_q_len;
1843   memcpy (tp, rsa_q, rsa_q_len);
1844   tp += rsa_q_len;
1845
1846   assert (tp - template == template_len);
1847
1848
1849   /* Obviously we need to remove the cached public key.  */
1850   xfree (app->app_local->pk[keyno].key);
1851   app->app_local->pk[keyno].key = NULL;
1852   app->app_local->pk[keyno].keylen = 0;
1853   app->app_local->pk[keyno].read_done = 0;
1854
1855   /* Prepare for storing the key.  */
1856   err = verify_chv3 (app, pincb, pincb_arg);
1857   if (err)
1858     goto leave;
1859
1860   /* Store the key. */
1861   err = iso7816_put_data (app->slot,
1862                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1863                          template, template_len);
1864   if (err)
1865     {
1866       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
1867       goto leave;
1868     }
1869  
1870   err = store_fpr (app->slot, keyno, created_at,
1871                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
1872                   fprbuf, app->card_version);
1873   if (err)
1874     goto leave;
1875
1876
1877  leave:
1878   xfree (template);
1879   return err;
1880 }
1881
1882
1883 /* Handle the GENKEY command. */
1884 static gpg_error_t 
1885 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
1886           gpg_error_t (*pincb)(void*, const char *, char **),
1887           void *pincb_arg)
1888 {
1889   int rc;
1890   char numbuf[30];
1891   unsigned char fprbuf[20];
1892   const unsigned char *keydata, *m, *e;
1893   unsigned char *buffer = NULL;
1894   size_t buflen, keydatalen, mlen, elen;
1895   time_t created_at;
1896   int keyno = atoi (keynostr);
1897   int force = (flags & 1);
1898   time_t start_at;
1899
1900   if (keyno < 1 || keyno > 3)
1901     return gpg_error (GPG_ERR_INV_ID);
1902   keyno--;
1903
1904   /* We flush the cache to increase the traffic before a key
1905      generation.  This _might_ help a card to gather more entropy. */
1906   flush_cache (app);
1907
1908   /* Obviously we need to remove the cached public key.  */
1909   xfree (app->app_local->pk[keyno].key);
1910   app->app_local->pk[keyno].key = NULL;
1911   app->app_local->pk[keyno].keylen = 0;
1912   app->app_local->pk[keyno].read_done = 0;
1913
1914   /* Check whether a key already exists.  */
1915   rc = does_key_exist (app, keyno, force);
1916   if (rc)
1917     return rc;
1918
1919   /* Prepare for key generation by verifying the ADmin PIN.  */
1920   rc = verify_chv3 (app, pincb, pincb_arg);
1921   if (rc)
1922     goto leave;
1923    
1924 #if 1
1925   log_info (_("please wait while key is being generated ...\n"));
1926   start_at = time (NULL);
1927   rc = iso7816_generate_keypair 
1928 #else
1929 #warning key generation temporary replaced by reading an existing key.
1930   rc = iso7816_read_public_key
1931 #endif
1932     (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
1933                                        keyno == 1? "\xB8" : "\xA4"),
1934      2,
1935      &buffer, &buflen);
1936   if (rc)
1937     {
1938       rc = gpg_error (GPG_ERR_CARD);
1939       log_error (_("generating key failed\n"));
1940       goto leave;
1941     }
1942   log_info (_("key generation completed (%d seconds)\n"),
1943             (int)(time (NULL) - start_at));
1944   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1945   if (!keydata)
1946     {
1947       rc = gpg_error (GPG_ERR_CARD);
1948       log_error (_("response does not contain the public key data\n"));
1949       goto leave;
1950     }
1951  
1952   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1953   if (!m)
1954     {
1955       rc = gpg_error (GPG_ERR_CARD);
1956       log_error (_("response does not contain the RSA modulus\n"));
1957       goto leave;
1958     }
1959 /*    log_printhex ("RSA n:", m, mlen); */
1960   send_key_data (ctrl, "n", m, mlen);
1961
1962   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1963   if (!e)
1964     {
1965       rc = gpg_error (GPG_ERR_CARD);
1966       log_error (_("response does not contain the RSA public exponent\n"));
1967       goto leave;
1968     }
1969 /*    log_printhex ("RSA e:", e, elen); */
1970   send_key_data (ctrl, "e", e, elen);
1971
1972   created_at = gnupg_get_time ();
1973   sprintf (numbuf, "%lu", (unsigned long)created_at);
1974   send_status_info (ctrl, "KEY-CREATED-AT",
1975                     numbuf, (size_t)strlen(numbuf), NULL, 0);
1976
1977   rc = store_fpr (app->slot, keyno, (u32)created_at,
1978                   m, mlen, e, elen, fprbuf, app->card_version);
1979   if (rc)
1980     goto leave;
1981   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1982
1983
1984  leave:
1985   xfree (buffer);
1986   return rc;
1987 }
1988
1989
1990 static unsigned long
1991 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
1992 {
1993   unsigned long ul;
1994
1995   if (valuelen == 3 )
1996     ul = (value[0] << 16) | (value[1] << 8) | value[2];
1997   else
1998     {
1999       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2000       ul = 0;
2001     }
2002   return ul;
2003 }
2004
2005 static unsigned long
2006 get_sig_counter (app_t app)
2007 {
2008   void *relptr;
2009   unsigned char *value;
2010   size_t valuelen;
2011   unsigned long ul;
2012
2013   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2014   if (!relptr)
2015     return 0;
2016   ul = convert_sig_counter_value (value, valuelen);
2017   xfree (relptr);
2018   return ul;
2019 }
2020
2021 static gpg_error_t
2022 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2023 {
2024   const unsigned char *fpr;
2025   unsigned char *buffer;
2026   size_t buflen, n;
2027   int rc, i;
2028   
2029   assert (keyno >= 1 && keyno <= 3);
2030
2031   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2032   if (rc)
2033     {
2034       log_error (_("error reading application data\n"));
2035       return gpg_error (GPG_ERR_GENERAL);
2036     }
2037   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2038   if (!fpr || n != 60)
2039     {
2040       xfree (buffer);
2041       log_error (_("error reading fingerprint DO\n"));
2042       return gpg_error (GPG_ERR_GENERAL);
2043     }
2044   fpr += (keyno-1)*20;
2045   for (i=0; i < 20; i++)
2046     if (sha1fpr[i] != fpr[i])
2047       {
2048         xfree (buffer);
2049         return gpg_error (GPG_ERR_WRONG_SECKEY);
2050       }
2051   xfree (buffer);
2052   return 0;
2053 }
2054
2055
2056   /* If a fingerprint has been specified check it against the one on
2057      the card.  This is allows for a meaningful error message in case
2058      the key on the card has been replaced but the shadow information
2059      known to gpg was not updated.  If there is no fingerprint we
2060      assume that this is okay. */
2061 static gpg_error_t
2062 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2063 {
2064   unsigned char tmp[20];
2065   const char *s;
2066   int n;
2067
2068   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2069     ;
2070   if (n != 40)
2071     return gpg_error (GPG_ERR_INV_ID);
2072   else if (!*s)
2073     ; /* okay */
2074   else
2075     return gpg_error (GPG_ERR_INV_ID);
2076
2077   for (s=fpr, n=0; n < 20; s += 2, n++)
2078         tmp[n] = xtoi_2 (s);
2079   return compare_fingerprint (app, keyno, tmp);
2080 }
2081
2082
2083
2084 /* Compute a digital signature on INDATA which is expected to be the
2085    raw message digest. For this application the KEYIDSTR consists of
2086    the serialnumber and the fingerprint delimited by a slash.
2087
2088    Note that this function may return the error code
2089    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2090    not match the one required for the requested action (e.g. the
2091    serial number does not match). */
2092 static gpg_error_t 
2093 do_sign (app_t app, const char *keyidstr, int hashalgo,
2094          gpg_error_t (*pincb)(void*, const char *, char **),
2095          void *pincb_arg,
2096          const void *indata, size_t indatalen,
2097          unsigned char **outdata, size_t *outdatalen )
2098 {
2099   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
2100   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2101     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
2102   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2103   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2104     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
2105   int rc;
2106   unsigned char data[35];
2107   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2108   const char *s;
2109   int n;
2110   const char *fpr = NULL;
2111   unsigned long sigcount;
2112
2113   if (!keyidstr || !*keyidstr)
2114     return gpg_error (GPG_ERR_INV_VALUE);
2115   if (indatalen == 20)
2116     ;
2117   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_SHA1
2118            && !memcmp (indata, sha1_prefix, 15))
2119     ;
2120   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_RMD160
2121            && !memcmp (indata, rmd160_prefix, 15))
2122     ;
2123   else
2124     {
2125       log_error (_("card does not support digest algorithm %s\n"),
2126                  gcry_md_algo_name (hashalgo));
2127       return gpg_error (GPG_ERR_INV_VALUE);
2128     }
2129
2130   /* Check whether an OpenPGP card of any version has been requested. */
2131   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2132     return gpg_error (GPG_ERR_INV_ID);
2133   
2134   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2135     ;
2136   if (n != 32)
2137     return gpg_error (GPG_ERR_INV_ID);
2138   else if (!*s)
2139     ; /* no fingerprint given: we allow this for now. */
2140   else if (*s == '/')
2141     fpr = s + 1; 
2142   else
2143     return gpg_error (GPG_ERR_INV_ID);
2144
2145   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2146     tmp_sn[n] = xtoi_2 (s);
2147
2148   if (app->serialnolen != 16)
2149     return gpg_error (GPG_ERR_INV_CARD);
2150   if (memcmp (app->serialno, tmp_sn, 16))
2151     return gpg_error (GPG_ERR_WRONG_CARD);
2152
2153   /* If a fingerprint has been specified check it against the one on
2154      the card.  This is allows for a meaningful error message in case
2155      the key on the card has been replaced but the shadow information
2156      known to gpg was not updated.  If there is no fingerprint, gpg
2157      will detect a bogus signature anyway due to the
2158      verify-after-signing feature. */
2159   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2160   if (rc)
2161     return rc;
2162
2163   if (hashalgo == GCRY_MD_SHA1)
2164     memcpy (data, sha1_prefix, 15);
2165   else if (hashalgo == GCRY_MD_RMD160)
2166     memcpy (data, rmd160_prefix, 15);
2167   else 
2168     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2169   memcpy (data+15, indata, indatalen);
2170
2171   sigcount = get_sig_counter (app);
2172   log_info (_("signatures created so far: %lu\n"), sigcount);
2173
2174   if (!app->did_chv1 || app->force_chv1 ) 
2175     {
2176       char *pinvalue;
2177
2178       {
2179         char *prompt;
2180 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
2181
2182         prompt = malloc (strlen (PROMPTSTRING) + 50);
2183         if (!prompt)
2184           return gpg_error_from_errno (errno);
2185         sprintf (prompt, PROMPTSTRING, sigcount);
2186         rc = pincb (pincb_arg, prompt, &pinvalue); 
2187         free (prompt);
2188 #undef PROMPTSTRING
2189       }
2190       if (rc)
2191         {
2192           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
2193           return rc;
2194         }
2195
2196       if (strlen (pinvalue) < 6)
2197         {
2198           log_error (_("PIN for CHV%d is too short;"
2199                        " minimum length is %d\n"), 1, 6);
2200           xfree (pinvalue);
2201           return gpg_error (GPG_ERR_BAD_PIN);
2202         }
2203
2204       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
2205       if (rc)
2206         {
2207           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2208           xfree (pinvalue);
2209           flush_cache_after_error (app);
2210           return rc;
2211         }
2212       app->did_chv1 = 1;
2213       if (!app->did_chv2)
2214         {
2215           /* We should also verify CHV2. */
2216           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2217           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2218             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2219           if (rc)
2220             {
2221               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2222               xfree (pinvalue);
2223               flush_cache_after_error (app);
2224               return rc;
2225             }
2226           app->did_chv2 = 1;
2227         }
2228       xfree (pinvalue);
2229     }
2230
2231   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
2232   return rc;
2233 }
2234
2235 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2236    on INDATA which is expected to be the raw message digest. For this
2237    application the KEYIDSTR consists of the serialnumber and the
2238    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2239    be given.
2240
2241    Note that this function may return the error code
2242    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2243    not match the one required for the requested action (e.g. the
2244    serial number does not match). */
2245 static gpg_error_t 
2246 do_auth (app_t app, const char *keyidstr,
2247          gpg_error_t (*pincb)(void*, const char *, char **),
2248          void *pincb_arg,
2249          const void *indata, size_t indatalen,
2250          unsigned char **outdata, size_t *outdatalen )
2251 {
2252   int rc;
2253   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2254   const char *s;
2255   int n;
2256   const char *fpr = NULL;
2257
2258   if (!keyidstr || !*keyidstr)
2259     return gpg_error (GPG_ERR_INV_VALUE);
2260   if (indatalen > 50) /* For a 1024 bit key. */
2261     return gpg_error (GPG_ERR_INV_VALUE);
2262
2263   /* Check whether an OpenPGP card of any version has been requested. */
2264   if (!strcmp (keyidstr, "OPENPGP.3"))
2265     ;
2266   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2267     return gpg_error (GPG_ERR_INV_ID);
2268   else
2269     {
2270       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2271         ;
2272       if (n != 32)
2273         return gpg_error (GPG_ERR_INV_ID);
2274       else if (!*s)
2275         ; /* no fingerprint given: we allow this for now. */
2276       else if (*s == '/')
2277         fpr = s + 1; 
2278       else
2279         return gpg_error (GPG_ERR_INV_ID);
2280
2281       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2282         tmp_sn[n] = xtoi_2 (s);
2283       
2284       if (app->serialnolen != 16)
2285         return gpg_error (GPG_ERR_INV_CARD);
2286       if (memcmp (app->serialno, tmp_sn, 16))
2287         return gpg_error (GPG_ERR_WRONG_CARD);
2288     }
2289
2290   /* If a fingerprint has been specified check it against the one on
2291      the card.  This is allows for a meaningful error message in case
2292      the key on the card has been replaced but the shadow information
2293      known to gpg was not updated.  If there is no fingerprint, gpg
2294      will detect a bogus signature anyway due to the
2295      verify-after-signing feature. */
2296   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2297   if (rc)
2298     return rc;
2299
2300   rc = verify_chv2 (app, pincb, pincb_arg);
2301   if (!rc)
2302     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2303                                         outdata, outdatalen);
2304   return rc;
2305 }
2306
2307
2308 static gpg_error_t 
2309 do_decipher (app_t app, const char *keyidstr,
2310              gpg_error_t (*pincb)(void*, const char *, char **),
2311              void *pincb_arg,
2312              const void *indata, size_t indatalen,
2313              unsigned char **outdata, size_t *outdatalen )
2314 {
2315   int rc;
2316   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2317   const char *s;
2318   int n;
2319   const char *fpr = NULL;
2320
2321   if (!keyidstr || !*keyidstr || !indatalen)
2322     return gpg_error (GPG_ERR_INV_VALUE);
2323
2324   /* Check whether an OpenPGP card of any version has been requested. */
2325   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2326     return gpg_error (GPG_ERR_INV_ID);
2327   
2328   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2329     ;
2330   if (n != 32)
2331     return gpg_error (GPG_ERR_INV_ID);
2332   else if (!*s)
2333     ; /* no fingerprint given: we allow this for now. */
2334   else if (*s == '/')
2335     fpr = s + 1; 
2336   else
2337     return gpg_error (GPG_ERR_INV_ID);
2338
2339   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2340     tmp_sn[n] = xtoi_2 (s);
2341
2342   if (app->serialnolen != 16)
2343     return gpg_error (GPG_ERR_INV_CARD);
2344   if (memcmp (app->serialno, tmp_sn, 16))
2345     return gpg_error (GPG_ERR_WRONG_CARD);
2346
2347   /* If a fingerprint has been specified check it against the one on
2348      the card.  This is allows for a meaningful error message in case
2349      the key on the card has been replaced but the shadow information
2350      known to gpg was not updated.  If there is no fingerprint, the
2351      decryption will won't produce the right plaintext anyway. */
2352   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
2353   if (rc)
2354     return rc;
2355
2356   rc = verify_chv2 (app, pincb, pincb_arg);
2357   if (!rc)
2358     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
2359                            outdata, outdatalen);
2360   return rc;
2361 }
2362
2363
2364 /* Perform a simple verify operation for CHV1 and CHV2, so that
2365    further operations won't ask for CHV2 and it is possible to do a
2366    cheap check on the PIN: If there is something wrong with the PIN
2367    entry system, only the regular CHV will get blocked and not the
2368    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
2369    optional fingerprint part will be ignored.
2370
2371    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
2372    the "[CHV3]" being a literal string:  The Admin Pin is checked if
2373    and only if the retry counter is still at 3. */
2374 static gpg_error_t 
2375 do_check_pin (app_t app, const char *keyidstr,
2376               gpg_error_t (*pincb)(void*, const char *, char **),
2377               void *pincb_arg)
2378 {
2379   unsigned char tmp_sn[20]; 
2380   const char *s;
2381   int n;
2382   int admin_pin = 0;
2383
2384   if (!keyidstr || !*keyidstr)
2385     return gpg_error (GPG_ERR_INV_VALUE);
2386
2387   /* Check whether an OpenPGP card of any version has been requested. */
2388   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2389     return gpg_error (GPG_ERR_INV_ID);
2390   
2391   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2392     ;
2393   if (n != 32)
2394     return gpg_error (GPG_ERR_INV_ID);
2395   else if (!*s)
2396     ; /* No fingerprint given: we allow this for now. */
2397   else if (*s == '/')
2398     ; /* We ignore a fingerprint. */
2399   else if (!strcmp (s, "[CHV3]") )
2400     admin_pin = 1;
2401   else
2402     return gpg_error (GPG_ERR_INV_ID);
2403
2404   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2405     tmp_sn[n] = xtoi_2 (s);
2406
2407   if (app->serialnolen != 16)
2408     return gpg_error (GPG_ERR_INV_CARD);
2409   if (memcmp (app->serialno, tmp_sn, 16))
2410     return gpg_error (GPG_ERR_WRONG_CARD);
2411
2412   /* Yes, there is a race conditions: The user might pull the card
2413      right here and we won't notice that.  However this is not a
2414      problem and the check above is merely for a graceful failure
2415      between operations. */
2416
2417   if (admin_pin)
2418     {
2419       void *relptr;
2420       unsigned char *value;
2421       size_t valuelen;
2422       int count;
2423       
2424       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2425       if (!relptr || valuelen < 7)
2426         {
2427           log_error (_("error retrieving CHV status from card\n"));
2428           xfree (relptr);
2429           return gpg_error (GPG_ERR_CARD);
2430         }
2431       count = value[6];
2432       xfree (relptr);
2433
2434       if (!count)
2435         {
2436           log_info (_("card is permanently locked!\n"));
2437           return gpg_error (GPG_ERR_BAD_PIN);
2438         }
2439       else if (value[6] < 3)
2440         {
2441           log_info (_("verification of Admin PIN is currently prohibited "
2442                       "through this command\n"));
2443           return gpg_error (GPG_ERR_GENERAL);
2444         }
2445
2446       app->did_chv3 = 0; /* Force verification.  */
2447       return verify_chv3 (app, pincb, pincb_arg);
2448     }
2449   else
2450     return verify_chv2 (app, pincb, pincb_arg);
2451 }
2452
2453
2454
2455
2456 /* Select the OpenPGP application on the card in SLOT.  This function
2457    must be used before any other OpenPGP application functions. */
2458 gpg_error_t
2459 app_select_openpgp (app_t app)
2460 {
2461   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
2462   int slot = app->slot;
2463   int rc;
2464   unsigned char *buffer;
2465   size_t buflen;
2466   void *relptr;
2467   
2468   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
2469      special flag value. */
2470   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
2471   if (!rc)
2472     {
2473       unsigned int manufacturer;
2474
2475       app->apptype = "OPENPGP";
2476
2477       app->did_chv1 = 0;
2478       app->did_chv2 = 0;
2479       app->did_chv3 = 0;
2480       app->app_local = NULL;
2481
2482       /* The OpenPGP card returns the serial number as part of the
2483          AID; because we prefer to use OpenPGP serial numbers, we
2484          replace a possibly already set one from a EF.GDO with this
2485          one.  Note, that for current OpenPGP cards, no EF.GDO exists
2486          and thus it won't matter at all. */
2487       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
2488       if (rc)
2489         goto leave;
2490       if (opt.verbose)
2491         {
2492           log_info ("AID: ");
2493           log_printhex ("", buffer, buflen);
2494         }
2495
2496       app->card_version = buffer[6] << 8;
2497       app->card_version |= buffer[7];
2498       manufacturer = (buffer[8]<<8 | buffer[9]);
2499
2500       xfree (app->serialno);
2501       app->serialno = buffer;
2502       app->serialnolen = buflen;
2503       buffer = NULL;
2504       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2505       if (!app->app_local)
2506         {
2507           rc = gpg_error (gpg_err_code_from_errno (errno));
2508           goto leave;
2509         }
2510
2511       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
2512       if (!relptr)
2513         {
2514           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2515                      "CHV Status Bytes");
2516           goto leave;
2517         }
2518       app->force_chv1 = (buflen && *buffer == 0);
2519       xfree (relptr);
2520
2521       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
2522       if (!relptr)
2523         {
2524           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2525                      "Extended Capability Flags" );
2526           goto leave;
2527         }
2528       if (buflen)
2529         {
2530           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
2531           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
2532           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
2533           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
2534         }
2535       xfree (relptr);
2536       
2537       /* Some of the first cards accidently don't set the
2538          CHANGE_FORCE_CHV bit but allow it anyway. */
2539       if (app->card_version <= 0x0100 && manufacturer == 1)
2540         app->app_local->extcap.change_force_chv = 1;
2541
2542       parse_login_data (app);
2543
2544       if (opt.verbose > 1)
2545         dump_all_do (slot);
2546
2547       app->fnc.deinit = do_deinit;
2548       app->fnc.learn_status = do_learn_status;
2549       app->fnc.readkey = do_readkey;
2550       app->fnc.getattr = do_getattr;
2551       app->fnc.setattr = do_setattr;
2552       app->fnc.writekey = do_writekey;
2553       app->fnc.genkey = do_genkey;
2554       app->fnc.sign = do_sign;
2555       app->fnc.auth = do_auth;
2556       app->fnc.decipher = do_decipher;
2557       app->fnc.change_pin = do_change_pin;
2558       app->fnc.check_pin = do_check_pin;
2559    }
2560
2561 leave:
2562   if (rc)
2563     do_deinit (app);
2564   return rc;
2565 }
2566
2567
2568