Cleanups, fixes and PC/SC support
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "scdaemon.h"
29 #include "app-common.h"
30 #include "iso7816.h"
31
32
33
34 static struct {
35   int tag;
36   int constructed;
37   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
38   int binary;
39   char *desc;
40 } data_objects[] = {
41   { 0x005E, 0,    0, 1, "Login Data" },
42   { 0x5F50, 0,    0, 0, "URL" },
43   { 0x0065, 1,    0, 1, "Cardholder Related Data"},
44   { 0x005B, 0, 0x65, 0, "Name" },
45   { 0x5F2D, 0, 0x65, 0, "Language preferences" },
46   { 0x5F35, 0, 0x65, 0, "Sex" },
47   { 0x006E, 1,    0, 1, "Application Related Data" },
48   { 0x004F, 0, 0x6E, 1, "AID" },
49   { 0x0073, 1,    0, 1, "Discretionary Data Objects" },
50   { 0x0047, 0, 0x6E, 1, "Card Capabilities" },
51   { 0x00C0, 0, 0x6E, 1, "Extended Card Capabilities" },
52   { 0x00C1, 0, 0x6E, 1, "Algorithm Attributes Signature" },
53   { 0x00C2, 0, 0x6E, 1, "Algorithm Attributes Decryption" },
54   { 0x00C3, 0, 0x6E, 1, "Algorithm Attributes Authentication" },
55   { 0x00C4, 0, 0x6E, 1, "CHV Status Bytes" },
56   { 0x00C5, 0, 0x6E, 1, "Fingerprints" },
57   { 0x00C6, 0, 0x6E, 1, "CA Fingerprints" },
58   { 0x007A, 1,    0, 1, "Security Support Template" },
59   { 0x0093, 0, 0x7A, 1, "Digital Signature Counter" },
60   { 0 }
61 };
62
63
64 static unsigned long get_sig_counter (APP app);
65
66
67 /* Locate a TLV encoded data object in BUFFER of LENGTH and
68    return a pointer to value as well as its length in NBYTES.  Return
69    NULL if it was not found.  Note, that the function does not check
70    whether the value fits into the provided buffer. 
71
72    FIXME: Move this to an extra file, it is mostly duplicated from card.c.
73 */
74 static const unsigned char *
75 find_tlv (const unsigned char *buffer, size_t length,
76           int tag, size_t *nbytes, int nestlevel)
77 {
78   const unsigned char *s = buffer;
79   size_t n = length;
80   size_t len;
81   int this_tag;
82   int composite;
83     
84   for (;;)
85     {
86       buffer = s;
87       if (n < 2)
88         return NULL; /* buffer definitely too short for tag and length. */
89       if (!*s || *s == 0xff)
90         { /* Skip optional filler between TLV objects. */
91           s++;
92           n--;
93           continue;
94         }
95       composite = !!(*s & 0x20);
96       if ((*s & 0x1f) == 0x1f)
97         { /* more tag bytes to follow */
98           s++;
99           n--;
100           if (n < 2)
101             return NULL; /* buffer definitely too short for tag and length. */
102           if ((*s & 0x1f) == 0x1f)
103             return NULL; /* We support only up to 2 bytes. */
104           this_tag = (s[-1] << 8) | (s[0] & 0x7f);
105         }
106       else
107         this_tag = s[0];
108       len = s[1];
109       s += 2; n -= 2;
110       if (len < 0x80)
111         ;
112       else if (len == 0x81)
113         { /* One byte length follows. */
114           if (!n)
115             return NULL; /* we expected 1 more bytes with the length. */
116           len = s[0];
117           s++; n--;
118         }
119       else if (len == 0x82)
120         { /* Two byte length follows. */
121           if (n < 2)
122             return NULL; /* we expected 2 more bytes with the length. */
123           len = (s[0] << 8) | s[1];
124           s += 2; n -= 2;
125         }
126       else
127         return NULL; /* APDU limit is 65535, thus it does not make
128                         sense to assume longer length fields. */
129
130       if (composite && nestlevel < 100)
131         { /* Dive into this composite DO after checking for too deep
132              nesting. */
133           const unsigned char *tmp_s;
134           size_t tmp_len;
135           
136           tmp_s = find_tlv (s, len, tag, &tmp_len, nestlevel+1);
137           if (tmp_s)
138             {
139               *nbytes = tmp_len;
140               return tmp_s;
141             }
142         }
143
144       if (this_tag == tag)
145         {
146           *nbytes = len;
147           return s;
148         }
149       if (len > n)
150         return NULL; /* buffer too short to skip to the next tag. */
151       s += len; n -= len;
152     }
153 }
154
155
156 /* Get the DO identified by TAG from the card in SLOT and return a
157    buffer with its content in RESULT and NBYTES.  The return value is
158    NULL if not found or a pointer which must be used to release the
159    buffer holding value. */
160 static void *
161 get_one_do (int slot, int tag, unsigned char **result, size_t *nbytes)
162 {
163   int rc, i;
164   unsigned char *buffer;
165   size_t buflen;
166   unsigned char *value;
167   size_t valuelen;
168
169   *result = NULL;
170   *nbytes = 0;
171   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
172     ;
173
174   value = NULL;
175   rc = -1;
176   if (data_objects[i].tag && data_objects[i].get_from)
177     {
178       rc = iso7816_get_data (slot, data_objects[i].get_from,
179                              &buffer, &buflen);
180       if (!rc)
181         {
182           const unsigned char *s;
183
184           s = find_tlv (buffer, buflen, tag, &valuelen, 0);
185           if (!s)
186             value = NULL; /* not found */
187           else if (valuelen > buflen - (s - buffer))
188             {
189               log_error ("warning: constructed DO too short\n");
190               value = NULL;
191               xfree (buffer); buffer = NULL;
192             }
193           else
194             value = buffer + (s - buffer);
195         }
196     }
197
198   if (!value) /* Not in a constructed DO, try simple. */
199     {
200       rc = iso7816_get_data (slot, tag, &buffer, &buflen);
201       if (!rc)
202         {
203           value = buffer;
204           valuelen = buflen;
205         }
206     }
207
208   if (!rc)
209     {
210       *nbytes = valuelen;
211       *result = value;
212       return buffer;
213     }
214   return NULL;
215 }
216
217
218 static void
219 dump_all_do (int slot)
220 {
221   int rc, i, j;
222   unsigned char *buffer;
223   size_t buflen;
224   
225   for (i=0; data_objects[i].tag; i++)
226     {
227       if (data_objects[i].get_from)
228         continue;
229
230       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
231       if (gpg_error (rc) == GPG_ERR_NO_OBJ)
232         ;
233       else if (rc) 
234         log_info ("DO `%s' not available: %s\n",
235                   data_objects[i].desc, gpg_strerror (rc));
236       else
237         {
238           if (data_objects[i].binary)
239             {
240               log_info ("DO `%s': ", data_objects[i].desc);
241               log_printhex ("", buffer, buflen);
242             }
243           else
244             log_info ("DO `%s': `%.*s'\n",
245                       data_objects[i].desc,
246                       (int)buflen, buffer); /* FIXME: sanitize */
247
248           if (data_objects[i].constructed)
249             {
250               for (j=0; data_objects[j].tag; j++)
251                 {
252                   const unsigned char *value;
253                   size_t valuelen;
254                   
255                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
256                     continue;
257                   value = find_tlv (buffer, buflen,
258                                     data_objects[j].tag, &valuelen, 0);
259                   if (!value)
260                     ; /* not found */
261                   else if (valuelen > buflen - (value - buffer))
262                     log_error ("warning: constructed DO too short\n");
263                   else
264                     {
265                       if (data_objects[j].binary)
266                         {
267                           log_info ("DO `%s': ", data_objects[j].desc);
268                           log_printhex ("", value, valuelen);
269                         }
270                       else
271                         log_info ("DO `%s': `%.*s'\n",
272                                   data_objects[j].desc,
273                                   (int)valuelen, value); /* FIXME: sanitize */
274                     }
275                 }
276             }
277         }
278       xfree (buffer); buffer = NULL;
279     }
280 }
281
282
283 /* Count the number of bits, assuming the A represents an unsigned big
284    integer of length LEN bytes. */
285 static unsigned int
286 count_bits (const unsigned char *a, size_t len)
287 {
288   unsigned int n = len * 8;
289   int i;
290
291   for (; len && !*a; len--, a++, n -=8)
292     ;
293   if (len)
294     {
295       for (i=7; i && !(*a & (1<<i)); i--)
296         n--;
297     }
298   return n;
299 }
300
301 /* Note, that FPR must be at least 20 bytes. */
302 static int 
303 store_fpr (int slot, int keynumber, u32 timestamp,
304            const unsigned char *m, size_t mlen,
305            const unsigned char *e, size_t elen, 
306            unsigned char *fpr, unsigned int card_version)
307 {
308   unsigned int n, nbits;
309   unsigned char *buffer, *p;
310   int rc;
311   
312   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
313     ;
314   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
315     ;
316
317   n = 6 + 2 + mlen + 2 + elen;
318   p = buffer = xtrymalloc (3 + n);
319   if (!buffer)
320     return out_of_core ();
321   
322   *p++ = 0x99;     /* ctb */
323   *p++ = n >> 8;   /* 2 byte length header */
324   *p++ = n;
325   *p++ = 4;        /* key packet version */
326   *p++ = timestamp >> 24;
327   *p++ = timestamp >> 16;
328   *p++ = timestamp >>  8;
329   *p++ = timestamp;
330   *p++ = 1; /* RSA */
331   nbits = count_bits (m, mlen);
332   *p++ = nbits >> 8;
333   *p++ = nbits;
334   memcpy (p, m, mlen); p += mlen;
335   nbits = count_bits (e, elen);
336   *p++ = nbits >> 8;
337   *p++ = nbits;
338   memcpy (p, e, elen); p += elen;
339     
340   log_printhex ("fprbuf:", buffer, n+3);
341   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
342
343   xfree (buffer);
344
345   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
346                                + keynumber, fpr, 20);
347   if (rc)
348     log_error ("failed to store the fingerprint: %s\n",gpg_strerror (rc));
349
350   return rc;
351 }
352
353        
354 static void
355 send_fpr_if_not_null (CTRL ctrl, const char *keyword,
356                       int number, const unsigned char *fpr)
357 {                      
358   int i;
359   char buf[41];
360   char numbuf[25];
361
362   for (i=0; i < 20 && !fpr[i]; i++)
363     ;
364   if (i==20)
365     return; /* All zero. */
366   for (i=0; i< 20; i++)
367     sprintf (buf+2*i, "%02X", fpr[i]);
368   if (number == -1)
369     *numbuf = 0; /* Don't print the key number */
370   else
371     sprintf (numbuf, "%d", number);
372   send_status_info (ctrl, keyword,
373                     numbuf, (size_t)strlen(numbuf),
374                     buf, (size_t)strlen (buf), NULL, 0);
375 }
376
377 static void
378 send_key_data (CTRL ctrl, const char *name, 
379                const unsigned char *a, size_t alen)
380 {
381   char *p, *buf = xmalloc (alen*2+1);
382   
383   for (p=buf; alen; a++, alen--, p += 2)
384     sprintf (p, "%02X", *a);
385
386   send_status_info (ctrl, "KEY-DATA",
387                     name, (size_t)strlen(name), 
388                     buf, (size_t)strlen (buf),
389                     NULL, 0);
390   xfree (buf);
391 }
392
393
394
395 static int
396 do_learn_status (APP app, CTRL ctrl)
397 {
398   void *relptr;
399   unsigned char *value;
400   size_t valuelen;
401   int i;
402
403   relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
404   if (relptr)
405     {
406       send_status_info (ctrl, "DISP-NAME", value, valuelen, NULL, 0);
407       xfree (relptr);
408     }
409   relptr = get_one_do (app->slot, 0x5F2D, &value, &valuelen);
410   if (relptr)
411     {
412       send_status_info (ctrl, "DISP-LANG", value, valuelen, NULL, 0);
413       xfree (relptr);
414     }
415   relptr = get_one_do (app->slot, 0x5F35, &value, &valuelen);
416   if (relptr)
417     {
418       send_status_info (ctrl, "DISP-SEX", value, valuelen, NULL, 0);
419       xfree (relptr);
420     }
421   relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
422   if (relptr)
423     {
424       send_status_info (ctrl, "PUBKEY-URL", value, valuelen, NULL, 0);
425       xfree (relptr);
426     }
427   relptr = get_one_do (app->slot, 0x005E, &value, &valuelen);
428   if (relptr)
429     {
430       send_status_info (ctrl, "LOGIN-DATA", value, valuelen, NULL, 0);
431       xfree (relptr);
432     }
433
434   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
435   if (relptr && valuelen >= 60)
436     {
437       for (i=0; i < 3; i++)
438         send_fpr_if_not_null (ctrl, "KEY-FPR", i+1, value+i*20);
439     }
440   xfree (relptr);
441   relptr = get_one_do (app->slot, 0x00C6, &value, &valuelen);
442   if (relptr && valuelen >= 60)
443     {
444       for (i=0; i < 3; i++)
445         send_fpr_if_not_null (ctrl, "CA-FPR", i+1, value+i*20);
446     }
447   xfree (relptr);
448   relptr = get_one_do (app->slot, 0x00C4, &value, &valuelen);
449   if (relptr)
450     {
451       char numbuf[7*23];
452
453       for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
454         sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
455       send_status_info (ctrl, "CHV-STATUS", numbuf, strlen (numbuf), NULL, 0);
456       xfree (relptr);
457     }
458
459   {
460     unsigned long ul = get_sig_counter (app);
461     char numbuf[23];
462
463     sprintf (numbuf, "%lu", ul);
464     send_status_info (ctrl, "SIG-COUNTER", numbuf, strlen (numbuf), NULL, 0);
465   }
466   return 0;
467 }
468
469
470 /* Handle the SETATTR operation. All arguments are already basically
471    checked. */
472 static int 
473 do_setattr (APP app, const char *name,
474             int (*pincb)(void*, const char *, char **),
475             void *pincb_arg,
476             const unsigned char *value, size_t valuelen)
477 {
478   gpg_error_t rc;
479   int idx;
480   static struct {
481     const char *name;
482     int tag;
483   } table[] = {
484     { "DISP-NAME",    0x005B },
485     { "LOGIN-DATA",   0x005E },
486     { "DISP-LANG",    0x5F2D },
487     { "DISP-SEX",     0x5F35 },
488     { "PUBKEY-URL",   0x5F50 },
489     { "CHV-STATUS-1", 0x00C4 },
490     { "CA-FPR-1",     0x00CA },
491     { "CA-FPR-2",     0x00CB },
492     { "CA-FPR-3",     0x00CC },
493     { NULL, 0 }
494   };
495
496
497   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
498     ;
499   if (!table[idx].name)
500     return gpg_error (GPG_ERR_INV_NAME); 
501
502   if (!app->did_chv3)
503     {
504       char *pinvalue;
505
506       rc = pincb (pincb_arg, "Admin PIN (CHV3)",
507                   &pinvalue);
508 /*        pinvalue = xstrdup ("12345678"); */
509 /*        rc = 0; */
510       if (rc)
511         {
512           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
513           return rc;
514         }
515
516       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
517       xfree (pinvalue);
518       if (rc)
519         {
520           log_error ("verify CHV3 failed: %s\n", gpg_strerror (rc));
521           rc = gpg_error (GPG_ERR_GENERAL);
522           return rc;
523         }
524       app->did_chv3 = 1;
525     }
526
527   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
528   if (rc)
529     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
530   /* FIXME: If this fails we should *once* try again after
531      doing a verify command, so that in case of a problem with
532      tracking the verify operation we have a fallback. */
533
534   return rc;
535 }
536
537 /* Handle the PASSWD command. */
538 static int 
539 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
540                int (*pincb)(void*, const char *, char **),
541                void *pincb_arg)
542 {
543   int rc = 0;
544   int chvno = atoi (chvnostr);
545   char *pinvalue;
546
547   if (reset_mode && chvno == 3)
548     {
549       rc = gpg_error (GPG_ERR_INV_ID);
550       goto leave;
551     }
552   else if (reset_mode || chvno == 3)
553     {
554       rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
555       if (rc)
556         {
557           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
558           goto leave;
559         }
560       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
561       xfree (pinvalue);
562       if (rc)
563         {
564           log_error ("verify CHV3 failed: rc=%s\n", gpg_strerror (rc));
565           goto leave;
566         }
567     }
568   else if (chvno == 1)
569     {
570       rc = pincb (pincb_arg, "Signature PIN", &pinvalue); 
571       if (rc)
572         {
573           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
574           goto leave;
575         }
576       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
577       xfree (pinvalue);
578       if (rc)
579         {
580           log_error ("verify CHV1 failed: rc=%s\n", gpg_strerror (rc));
581           goto leave;
582         }
583     }
584   else if (chvno == 2)
585     {
586       rc = pincb (pincb_arg, "Decryption PIN", &pinvalue); 
587       if (rc)
588         {
589           log_error ("error getting PIN: %s\n", gpg_strerror (rc));
590           goto leave;
591         }
592       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
593       xfree (pinvalue);
594       if (rc)
595         {
596           log_error ("verify CHV2 failed: rc=%s\n", gpg_strerror (rc));
597           goto leave;
598         }
599     }
600   else
601     {
602       rc = gpg_error (GPG_ERR_INV_ID);
603       goto leave;
604     }
605
606   
607   rc = pincb (pincb_arg, chvno == 1? "New Signature PIN" :
608                          chvno == 2? "New Decryption PIN" :
609                          chvno == 3? "New Admin PIN" : "?", &pinvalue); 
610   if (rc)
611     {
612       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
613       goto leave;
614     }
615
616   if (reset_mode)
617     rc = iso7816_reset_retry_counter (app->slot, 0x80 + chvno,
618                                       pinvalue, strlen (pinvalue));
619   else
620     rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
621                                         NULL, 0,
622                                         pinvalue, strlen (pinvalue));
623   xfree (pinvalue);
624
625
626  leave:
627   return rc;
628 }
629
630
631
632 /* Handle the GENKEY command. */
633 static int 
634 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
635           int (*pincb)(void*, const char *, char **),
636           void *pincb_arg)
637 {
638   int rc;
639   int i;
640   char numbuf[30];
641   unsigned char fprbuf[20];
642   const unsigned char *fpr;
643   const unsigned char *keydata, *m, *e;
644   unsigned char *buffer;
645   size_t buflen, keydatalen, n, mlen, elen;
646   time_t created_at;
647   int keyno = atoi (keynostr);
648   int force = (flags & 1);
649   time_t start_at;
650
651   if (keyno < 1 || keyno > 3)
652     return gpg_error (GPG_ERR_INV_ID);
653   keyno--;
654
655   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
656   if (rc)
657     {
658       log_error ("error reading application data\n");
659       return gpg_error (GPG_ERR_GENERAL);
660     }
661   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
662   if (!fpr || n != 60)
663     {
664       rc = gpg_error (GPG_ERR_GENERAL);
665       log_error ("error reading fingerprint DO\n");
666       goto leave;
667     }
668   fpr += 20*keyno;
669   for (i=0; i < 20 && !fpr[i]; i++)
670     ;
671   if (i!=20 && !force)
672     {
673       rc = gpg_error (GPG_ERR_EEXIST);
674       log_error ("key already exists\n");
675       goto leave;
676     }
677   else if (i!=20)
678     log_info ("existing key will be replaced\n");
679   else
680     log_info ("generating new key\n");
681
682   {
683     char *pinvalue;
684     rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
685     if (rc)
686       {
687         log_error ("error getting PIN: %s\n", gpg_strerror (rc));
688         return rc;
689       }
690     rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
691     xfree (pinvalue);
692   }
693   if (rc)
694     {
695       log_error ("verify CHV3 failed: rc=%s\n", gpg_strerror (rc));
696       goto leave;
697     }
698
699   xfree (buffer); buffer = NULL;
700 #if 1
701   log_info ("please wait while key is being generated ...\n");
702   start_at = time (NULL);
703   rc = iso7816_generate_keypair 
704 #else
705 #warning key generation temporary replaced by reading an existing key.
706   rc = iso7816_read_public_key
707 #endif
708                               (app->slot, 
709                                  keyno == 0? "\xB6" :
710                                  keyno == 1? "\xB8" : "\xA4",
711                                  2,
712                                  &buffer, &buflen);
713   if (rc)
714     {
715       rc = gpg_error (GPG_ERR_CARD);
716       log_error ("generating key failed\n");
717       goto leave;
718     }
719   log_info ("key generation completed (%d seconds)\n",
720             (int)(time (NULL) - start_at));
721   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
722   if (!keydata)
723     {
724       rc = gpg_error (GPG_ERR_CARD);
725       log_error ("response does not contain the public key data\n");
726       goto leave;
727     }
728  
729   m = find_tlv (keydata, keydatalen, 0x0081, &mlen, 0);
730   if (!m)
731     {
732       rc = gpg_error (GPG_ERR_CARD);
733       log_error ("response does not contain the RSA modulus\n");
734       goto leave;
735     }
736 /*    log_printhex ("RSA n:", m, mlen); */
737   send_key_data (ctrl, "n", m, mlen);
738
739   e = find_tlv (keydata, keydatalen, 0x0082, &elen, 0);
740   if (!e)
741     {
742       rc = gpg_error (GPG_ERR_CARD);
743       log_error ("response does not contain the RSA public exponent\n");
744       goto leave;
745     }
746 /*    log_printhex ("RSA e:", e, elen); */
747   send_key_data (ctrl, "e", e, elen);
748
749   created_at = gnupg_get_time ();
750   sprintf (numbuf, "%lu", (unsigned long)created_at);
751   send_status_info (ctrl, "KEY-CREATED-AT",
752                     numbuf, (size_t)strlen(numbuf), NULL, 0);
753
754   rc = store_fpr (app->slot, keyno, (u32)created_at,
755                   m, mlen, e, elen, fprbuf, app->card_version);
756   if (rc)
757     goto leave;
758   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
759
760
761  leave:
762   xfree (buffer);
763   return rc;
764 }
765
766
767 static unsigned long
768 get_sig_counter (APP app)
769 {
770   void *relptr;
771   unsigned char *value;
772   size_t valuelen;
773   unsigned long ul;
774
775   relptr = get_one_do (app->slot, 0x0093, &value, &valuelen);
776   if (!relptr)
777     return 0;
778   if (valuelen == 3 )
779     ul = (value[0] << 16) | (value[1] << 8) | value[2];
780   else
781     {
782       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
783       ul = 0;
784     }
785   xfree (relptr);
786   return ul;
787 }
788
789 static int
790 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
791 {
792   const unsigned char *fpr;
793   unsigned char *buffer;
794   size_t buflen, n;
795   int rc, i;
796   
797   assert (keyno >= 1 && keyno <= 3);
798
799   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
800   if (rc)
801     {
802       log_error ("error reading application data\n");
803       return gpg_error (GPG_ERR_GENERAL);
804     }
805   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
806   if (!fpr || n != 60)
807     {
808       xfree (buffer);
809       log_error ("error reading fingerprint DO\n");
810       return gpg_error (GPG_ERR_GENERAL);
811     }
812   fpr += (keyno-1)*20;
813   for (i=0; i < 20; i++)
814     if (sha1fpr[i] != fpr[i])
815       {
816         xfree (buffer);
817         return gpg_error (GPG_ERR_WRONG_SECKEY);
818       }
819   xfree (buffer);
820   return 0;
821 }
822
823
824
825 /* Compute a digital signature on INDATA which is expected to be the
826    raw message digest. For this application the KEYIDSTR consists of
827    the serialnumber and the fingerprint delimited by a slash.
828
829    Note that this fucntion may return the error code
830    GPG_ERR_WRONG_CARD to indicate that the card currently present does
831    not match the one required for the requested action (e.g. the
832    serial number does not match). */
833 static int 
834 do_sign (APP app, const char *keyidstr, int hashalgo,
835          int (*pincb)(void*, const char *, char **),
836          void *pincb_arg,
837          const void *indata, size_t indatalen,
838          unsigned char **outdata, size_t *outdatalen )
839 {
840   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
841   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
842     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
843   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
844   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
845     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
846   int rc;
847   unsigned char data[35];
848   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
849   const char *s;
850   int n;
851   const char *fpr = NULL;
852   unsigned long sigcount;
853
854   if (!keyidstr || !*keyidstr)
855     return gpg_error (GPG_ERR_INV_VALUE);
856   if (indatalen != 20)
857     return gpg_error (GPG_ERR_INV_VALUE);
858
859   /* Check whether an OpenPGP card of any version has been requested. */
860   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
861     return gpg_error (GPG_ERR_INV_ID);
862   
863   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
864     ;
865   if (n != 32)
866     return gpg_error (GPG_ERR_INV_ID);
867   else if (!*s)
868     ; /* no fingerprint given: we allow this for now. */
869   else if (*s == '/')
870     fpr = s + 1; 
871   else
872     return gpg_error (GPG_ERR_INV_ID);
873
874   for (s=keyidstr, n=0; n < 16; s += 2, n++)
875     tmp_sn[n] = xtoi_2 (s);
876
877   if (app->serialnolen != 16)
878     return gpg_error (GPG_ERR_INV_CARD);
879   if (memcmp (app->serialno, tmp_sn, 16))
880     return gpg_error (GPG_ERR_WRONG_CARD);
881
882   /* If a fingerprint has been specified check it against the one on
883      the card.  This is allows for a meaningful error message in case
884      the key on the card has been replaced but the shadow information
885      known to gpg was not updated.  If there is no fingerprint, gpg
886      will detect a bogus signature anyway due to the
887      verify-after-signing feature. */
888   if (fpr)
889     {
890       for (s=fpr, n=0; hexdigitp (s); s++, n++)
891         ;
892       if (n != 40)
893         return gpg_error (GPG_ERR_INV_ID);
894       else if (!*s)
895         ; /* okay */
896       else
897         return gpg_error (GPG_ERR_INV_ID);
898
899       for (s=fpr, n=0; n < 20; s += 2, n++)
900         tmp_sn[n] = xtoi_2 (s);
901       rc = compare_fingerprint (app, 1, tmp_sn);
902       if (rc)
903         return rc;
904     }
905
906   if (hashalgo == GCRY_MD_SHA1)
907     memcpy (data, sha1_prefix, 15);
908   else if (hashalgo == GCRY_MD_RMD160)
909     memcpy (data, rmd160_prefix, 15);
910   else 
911     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
912   memcpy (data+15, indata, indatalen);
913
914   sigcount = get_sig_counter (app);
915   log_info ("signatures created so far: %lu\n", sigcount);
916
917   /* FIXME: Check whether we are really required to enter the PIN for
918      each signature. There is a DO for this. */
919   if (!app->did_chv1 || 1) 
920     {
921       char *pinvalue;
922
923       {
924         char *prompt;
925         if (asprintf (&prompt, "Signature PIN [sigs done: %lu]", sigcount) < 0)
926           return gpg_error_from_errno (errno);
927         rc = pincb (pincb_arg, prompt, &pinvalue); 
928         free (prompt);
929       }
930 /*        pinvalue = xstrdup ("123456"); */
931 /*        rc = 0; */
932       if (rc)
933         {
934           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
935           return rc;
936         }
937
938       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
939       xfree (pinvalue);
940       if (rc)
941         {
942           log_error ("verify CHV1 failed\n");
943           rc = gpg_error (GPG_ERR_GENERAL);
944           return rc;
945         }
946       app->did_chv1 = 1;
947     }
948
949   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
950   return rc;
951 }
952
953 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
954    on INDATA which is expected to be the raw message digest. For this
955    application the KEYIDSTR consists of the serialnumber and the
956    fingerprint delimited by a slash.
957
958    Note that this fucntion may return the error code
959    GPG_ERR_WRONG_CARD to indicate that the card currently present does
960    not match the one required for the requested action (e.g. the
961    serial number does not match). */
962 static int 
963 do_auth (APP app, const char *keyidstr,
964          int (*pincb)(void*, const char *, char **),
965          void *pincb_arg,
966          const void *indata, size_t indatalen,
967          unsigned char **outdata, size_t *outdatalen )
968 {
969   int rc;
970   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
971   const char *s;
972   int n;
973   const char *fpr = NULL;
974
975   if (!keyidstr || !*keyidstr)
976     return gpg_error (GPG_ERR_INV_VALUE);
977   if (indatalen > 50) /* For a 1024 bit key. */
978     return gpg_error (GPG_ERR_INV_VALUE);
979
980   /* Check whether an OpenPGP card of any version has been requested. */
981   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
982     return gpg_error (GPG_ERR_INV_ID);
983   
984   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
985     ;
986   if (n != 32)
987     return gpg_error (GPG_ERR_INV_ID);
988   else if (!*s)
989     ; /* no fingerprint given: we allow this for now. */
990   else if (*s == '/')
991     fpr = s + 1; 
992   else
993     return gpg_error (GPG_ERR_INV_ID);
994
995   for (s=keyidstr, n=0; n < 16; s += 2, n++)
996     tmp_sn[n] = xtoi_2 (s);
997
998   if (app->serialnolen != 16)
999     return gpg_error (GPG_ERR_INV_CARD);
1000   if (memcmp (app->serialno, tmp_sn, 16))
1001     return gpg_error (GPG_ERR_WRONG_CARD);
1002
1003   /* If a fingerprint has been specified check it against the one on
1004      the card.  This is allows for a meaningful error message in case
1005      the key on the card has been replaced but the shadow information
1006      known to gpg was not updated.  If there is no fingerprint, gpg
1007      will detect a bogus signature anyway due to the
1008      verify-after-signing feature. */
1009   if (fpr)
1010     {
1011       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1012         ;
1013       if (n != 40)
1014         return gpg_error (GPG_ERR_INV_ID);
1015       else if (!*s)
1016         ; /* okay */
1017       else
1018         return gpg_error (GPG_ERR_INV_ID);
1019
1020       for (s=fpr, n=0; n < 20; s += 2, n++)
1021         tmp_sn[n] = xtoi_2 (s);
1022       rc = compare_fingerprint (app, 3, tmp_sn);
1023       if (rc)
1024         return rc;
1025     }
1026
1027   if (!app->did_chv2) 
1028     {
1029       char *pinvalue;
1030
1031       rc = pincb (pincb_arg, "Authentication/Decryption PIN", &pinvalue); 
1032       if (rc)
1033         {
1034           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1035           return rc;
1036         }
1037
1038       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1039       xfree (pinvalue);
1040       if (rc)
1041         {
1042           log_error ("verify CHV2 failed\n");
1043           rc = gpg_error (GPG_ERR_GENERAL);
1044           return rc;
1045         }
1046       app->did_chv2 = 1;
1047     }
1048
1049   rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1050                                       outdata, outdatalen);
1051   return rc;
1052 }
1053
1054
1055 static int 
1056 do_decipher (APP app, const char *keyidstr,
1057              int (pincb)(void*, const char *, char **),
1058              void *pincb_arg,
1059              const void *indata, size_t indatalen,
1060              unsigned char **outdata, size_t *outdatalen )
1061 {
1062   int rc;
1063   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1064   const char *s;
1065   int n;
1066   const char *fpr = NULL;
1067
1068   if (!keyidstr || !*keyidstr || !indatalen)
1069     return gpg_error (GPG_ERR_INV_VALUE);
1070
1071   /* Check whether an OpenPGP card of any version has been requested. */
1072   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1073     return gpg_error (GPG_ERR_INV_ID);
1074   
1075   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1076     ;
1077   if (n != 32)
1078     return gpg_error (GPG_ERR_INV_ID);
1079   else if (!*s)
1080     ; /* no fingerprint given: we allow this for now. */
1081   else if (*s == '/')
1082     fpr = s + 1; 
1083   else
1084     return gpg_error (GPG_ERR_INV_ID);
1085
1086   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1087     tmp_sn[n] = xtoi_2 (s);
1088
1089   if (app->serialnolen != 16)
1090     return gpg_error (GPG_ERR_INV_CARD);
1091   if (memcmp (app->serialno, tmp_sn, 16))
1092     return gpg_error (GPG_ERR_WRONG_CARD);
1093
1094   /* If a fingerprint has been specified check it against the one on
1095      the card.  This is allows for a meaningful error message in case
1096      the key on the card has been replaced but the shadow information
1097      known to gpg was not updated.  If there is no fingerprint, the
1098      decryption will won't produce the right plaintext anyway. */
1099   if (fpr)
1100     {
1101       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1102         ;
1103       if (n != 40)
1104         return gpg_error (GPG_ERR_INV_ID);
1105       else if (!*s)
1106         ; /* okay */
1107       else
1108         return gpg_error (GPG_ERR_INV_ID);
1109
1110       for (s=fpr, n=0; n < 20; s += 2, n++)
1111         tmp_sn[n] = xtoi_2 (s);
1112       rc = compare_fingerprint (app, 2, tmp_sn);
1113       if (rc)
1114         return rc;
1115     }
1116
1117   if (!app->did_chv2) 
1118     {
1119       char *pinvalue;
1120
1121       rc = pincb (pincb_arg, "Decryption PIN", &pinvalue); 
1122 /*        pinvalue = xstrdup ("123456"); */
1123 /*        rc = 0; */
1124       if (rc)
1125         {
1126           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1127           return rc;
1128         }
1129
1130       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1131       xfree (pinvalue);
1132       if (rc)
1133         {
1134           log_error ("verify CHV2 failed\n");
1135           rc = gpg_error (GPG_ERR_GENERAL);
1136           return rc;
1137         }
1138       app->did_chv2 = 1;
1139     }
1140   
1141   rc = iso7816_decipher (app->slot, indata, indatalen, outdata, outdatalen);
1142   return rc;
1143 }
1144
1145
1146
1147
1148 /* Select the OpenPGP application on the card in SLOT.  This function
1149    must be used before any other OpenPGP application functions. */
1150 int
1151 app_select_openpgp (APP app, unsigned char **sn, size_t *snlen)
1152 {
1153   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1154   int slot = app->slot;
1155   int rc;
1156   unsigned char *buffer;
1157   size_t buflen;
1158   
1159   rc = iso7816_select_application (slot, aid, sizeof aid);
1160   if (!rc)
1161     {
1162       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1163       if (rc)
1164         goto leave;
1165       if (opt.verbose)
1166         {
1167           log_info ("got AID: ");
1168           log_printhex ("", buffer, buflen);
1169         }
1170
1171       if (sn)
1172         {
1173           *sn = buffer;
1174           *snlen = buflen;
1175           app->card_version = buffer[6] << 8;
1176           app->card_version |= buffer[7];
1177         }
1178       else
1179         xfree (buffer);
1180
1181       if (opt.verbose > 1)
1182         dump_all_do (slot);
1183
1184       app->fnc.learn_status = do_learn_status;
1185       app->fnc.setattr = do_setattr;
1186       app->fnc.genkey = do_genkey;
1187       app->fnc.sign = do_sign;
1188       app->fnc.auth = do_auth;
1189       app->fnc.decipher = do_decipher;
1190       app->fnc.change_pin = do_change_pin;
1191    }
1192
1193 leave:
1194   return rc;
1195 }
1196
1197
1198
1199 /* This function is a hack to retrieve essential information about the
1200    card to be displayed by simple tools.  It mostly resembles what the
1201    LEARN command returns. All parameters return allocated strings or
1202    buffers or NULL if the data object is not available.  All returned
1203    values are sanitized. */
1204 int
1205 app_openpgp_cardinfo (APP app,
1206                       char **serialno,
1207                       char **disp_name,
1208                       char **pubkey_url,
1209                       unsigned char **fpr1,
1210                       unsigned char **fpr2,
1211                       unsigned char **fpr3)
1212 {
1213   int rc;
1214   void *relptr;
1215   unsigned char *value;
1216   size_t valuelen;
1217
1218   if (serialno)
1219     {
1220       time_t dummy;
1221
1222       *serialno = NULL;
1223       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1224       if (rc)
1225         {
1226           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1227           return rc;
1228         }
1229     }
1230       
1231   if (disp_name)
1232     {
1233       *disp_name = NULL;
1234       relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
1235       if (relptr)
1236         {
1237           *disp_name = make_printable_string (value, valuelen, 0);
1238           xfree (relptr);
1239         }
1240     }
1241
1242   if (pubkey_url)
1243     {
1244       *pubkey_url = NULL;
1245       relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
1246       if (relptr)
1247         {
1248           *pubkey_url = make_printable_string (value, valuelen, 0);
1249           xfree (relptr);
1250         }
1251     }
1252
1253   if (fpr1)
1254     *fpr1 = NULL;
1255   if (fpr2)
1256     *fpr2 = NULL;
1257   if (fpr3)
1258     *fpr3 = NULL;
1259   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
1260   if (relptr && valuelen >= 60)
1261     {
1262       if (fpr1)
1263         {
1264           *fpr1 = xmalloc (20);
1265           memcpy (*fpr1, value +  0, 20);
1266         }
1267       if (fpr2)
1268         {
1269           *fpr2 = xmalloc (20);
1270           memcpy (*fpr2, value + 20, 20);
1271         }
1272       if (fpr3)
1273         {
1274           *fpr3 = xmalloc (20);
1275           memcpy (*fpr3, value + 40, 20);
1276         }
1277     }
1278   xfree (relptr);
1279
1280   return 0;
1281 }
1282
1283
1284
1285 /* This function is currently only used by the sc-copykeys program to
1286    store a key on the smartcard.  APP ist the application handle,
1287    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1288    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1289    the key template to store. CREATED_AT is the timestamp used to
1290    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1291    RSA public exponent. This function silently overwrites an existing
1292    key.*/
1293 int 
1294 app_openpgp_storekey (APP app, int keyno,
1295                       unsigned char *template, size_t template_len,
1296                       time_t created_at,
1297                       const unsigned char *m, size_t mlen,
1298                       const unsigned char *e, size_t elen,
1299                       int (*pincb)(void*, const char *, char **),
1300                       void *pincb_arg)
1301 {
1302   int rc;
1303   unsigned char fprbuf[20];
1304
1305   if (keyno < 1 || keyno > 3)
1306     return gpg_error (GPG_ERR_INV_ID);
1307   keyno--;
1308
1309   {
1310     char *pinvalue;
1311     rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
1312     if (rc)
1313       {
1314         log_error ("error getting PIN: %s\n", gpg_strerror (rc));
1315         return rc;
1316       }
1317     rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1318     xfree (pinvalue);
1319   }
1320   if (rc)
1321     {
1322       log_error ("verify CHV3 failed: rc=%s\n", gpg_strerror (rc));
1323       goto leave;
1324     }
1325
1326   rc = iso7816_put_data (app->slot,
1327                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1328                          template, template_len);
1329   if (rc)
1330     {
1331       log_error ("failed to store the key: rc=%s\n", gpg_strerror (rc));
1332       rc = gpg_error (GPG_ERR_CARD);
1333       goto leave;
1334     }
1335  
1336 /*    log_printhex ("RSA n:", m, mlen);  */
1337 /*    log_printhex ("RSA e:", e, elen);  */
1338
1339   rc = store_fpr (app->slot, keyno, (u32)created_at,
1340                   m, mlen, e, elen, fprbuf, app->card_version);
1341
1342  leave:
1343   return rc;
1344 }
1345
1346
1347 /* Utility function for external tools: Read the public RSA key at
1348    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1349 int 
1350 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1351                      unsigned char **e, size_t *elen)
1352 {
1353   int rc;
1354   const unsigned char *keydata, *a;
1355   unsigned char *buffer;
1356   size_t buflen, keydatalen, alen;
1357
1358   *m = NULL;
1359   *e = NULL;
1360
1361   if (keyno < 1 || keyno > 3)
1362     return gpg_error (GPG_ERR_INV_ID);
1363   keyno--;
1364
1365   rc = iso7816_read_public_key(app->slot, 
1366                                keyno == 0? "\xB6" :
1367                                keyno == 1? "\xB8" : "\xA4",
1368                                2,
1369                                &buffer, &buflen);
1370   if (rc)
1371     {
1372       rc = gpg_error (GPG_ERR_CARD);
1373       log_error ("reading key failed\n");
1374       goto leave;
1375     }
1376
1377   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
1378   if (!keydata)
1379     {
1380       log_error ("response does not contain the public key data\n");
1381       rc = gpg_error (GPG_ERR_CARD);
1382       goto leave;
1383     }
1384  
1385   a = find_tlv (keydata, keydatalen, 0x0081, &alen, 0);
1386   if (!a)
1387     {
1388       log_error ("response does not contain the RSA modulus\n");
1389       rc = gpg_error (GPG_ERR_CARD);
1390       goto leave;
1391     }
1392   *mlen = alen;
1393   *m = xmalloc (alen);
1394   memcpy (*m, a, alen);
1395   
1396   a = find_tlv (keydata, keydatalen, 0x0082, &alen, 0);
1397   if (!e)
1398     {
1399       log_error ("response does not contain the RSA public exponent\n");
1400       rc = gpg_error (GPG_ERR_CARD);
1401       goto leave;
1402     }
1403   *elen = alen;
1404   *e = xmalloc (alen);
1405   memcpy (*e, a, alen);
1406
1407  leave:
1408   xfree (buffer);
1409   if (rc)
1410     { 
1411       xfree (*m); *m = NULL;
1412       xfree (*e); *e = NULL;
1413     }
1414   return rc;
1415 }