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