This commit was manufactured by cvs2svn to create branch
[gnupg.git] / scd / card.c
1 /* card.c - SCdaemon card functions
2  *      Copyright (C) 2002 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 <time.h>
27
28 #ifdef HAVE_OPENSC
29 #include <opensc/pkcs15.h>
30 #endif
31 #include <ksba.h>
32
33 #include "scdaemon.h"
34 #include "card-common.h"
35
36 /* Map the SC error codes to the GNUPG ones */
37 gpg_error_t
38 map_sc_err (int rc)
39 {
40   gpg_err_code_t e;
41
42   switch (rc)
43     {
44     case 0: e = 0; break;
45 #ifdef HAVE_OPENSC
46     case SC_ERROR_NOT_SUPPORTED:         e = GPG_ERR_NOT_SUPPORTED; break;
47     case SC_ERROR_PKCS15_APP_NOT_FOUND:  e = GPG_ERR_NO_PKCS15_APP; break;
48     case SC_ERROR_OUT_OF_MEMORY:         e = GPG_ERR_ENOMEM; break;
49     case SC_ERROR_CARD_NOT_PRESENT:      e = GPG_ERR_CARD_NOT_PRESENT; break;
50     case SC_ERROR_CARD_REMOVED:          e = GPG_ERR_CARD_REMOVED; break;
51     case SC_ERROR_INVALID_CARD:          e = GPG_ERR_INV_CARD; break;
52 #endif
53     default: e = GPG_ERR_CARD; break;
54     }
55   return gpg_err_make (GPG_ERR_SOURCE_UNKNOWN, e);
56 }
57
58 /* Get the keygrip from CERT, return 0 on success */
59 int
60 card_help_get_keygrip (KsbaCert cert, unsigned char *array)
61 {
62   gcry_sexp_t s_pkey;
63   int rc;
64   KsbaSexp p;
65   size_t n;
66   
67   p = ksba_cert_get_public_key (cert);
68   if (!p)
69     return -1; /* oops */
70   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
71   if (!n)
72     return -1; /* libksba did not return a proper S-expression */
73   rc = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
74   xfree (p);
75   if (rc)
76     return -1; /* can't parse that S-expression */
77   array = gcry_pk_get_keygrip (s_pkey, array);
78   gcry_sexp_release (s_pkey);
79   if (!array)
80     return -1; /* failed to calculate the keygrip */
81   return 0;
82 }
83
84
85
86
87
88
89 \f
90 /* Create a new context for the card and figures out some basic
91    information of the card.  Detects whgether a PKCS_15 application is
92    stored.
93
94    Common errors: GPG_ERR_CARD_NOT_PRESENT */
95 int
96 card_open (CARD *rcard)
97 {
98 #ifdef HAVE_OPENSC
99   CARD card;
100   int rc;
101
102   card = xtrycalloc (1, sizeof *card);
103   if (!card)
104     return out_of_core ();
105   card->reader = 0;
106   
107   rc = sc_establish_context (&card->ctx, "scdaemon");
108   if (rc)
109     {
110       log_error ("failed to establish SC context: %s\n", sc_strerror (rc));
111       rc = map_sc_err (rc);
112       goto leave;
113     }
114   if (card->reader >= card->ctx->reader_count)
115     {
116       log_error ("no card reader available\n");
117       rc = gpg_error (GPG_ERR_CARD);
118       goto leave;
119     }
120   card->ctx->error_file = log_get_stream ();
121   card->ctx->debug = opt.debug_sc;
122   card->ctx->debug_file = log_get_stream ();
123
124   if (sc_detect_card_presence (card->ctx->reader[card->reader], 0) != 1)
125     {
126       rc = gpg_error (GPG_ERR_CARD_NOT_PRESENT);
127       goto leave;
128     }
129
130   rc = sc_connect_card (card->ctx->reader[card->reader], 0, &card->scard);
131   if (rc)
132     {
133       log_error ("failed to connect card in reader %d: %s\n",
134                  card->reader, sc_strerror (rc));
135       rc = map_sc_err (rc);
136       goto leave;
137     }
138   if (opt.verbose)
139     log_info ("connected to card in reader %d using driver `%s'\n",
140               card->reader, card->scard->driver->name);
141
142   rc = sc_lock (card->scard);
143   if (rc)
144     {
145       log_error ("can't lock card in reader %d: %s\n",
146                  card->reader, sc_strerror (rc));
147       rc = map_sc_err (rc);
148       goto leave;
149     }
150
151     
152  leave:
153   if (rc)
154     card_close (card);
155   else
156     *rcard = card;
157
158   return rc;
159 #else
160   return gpg_error (GPG_ERR_NOT_SUPPORTED);
161 #endif
162 }
163
164
165 /* Close a card and release all resources */
166 void
167 card_close (CARD card)
168 {
169   if (card)
170     {
171 #ifdef HAVE_OPENSC
172       if (card->p15card)
173         {
174           sc_pkcs15_unbind (card->p15card);
175           card->p15card = NULL;
176         }
177       if (card->p15priv)
178         p15_release_private_data (card);
179       if (card->scard)
180         {
181           sc_unlock (card->scard);
182           sc_disconnect_card (card->scard, 0);
183           card->scard = NULL;
184         }
185       if (card->ctx)
186         {
187           sc_release_context (card->ctx);
188           card->ctx = NULL;
189         }
190 #endif
191       xfree (card);
192     }      
193 }
194
195 /* Locate a simple TLV encoded data object in BUFFER of LENGTH and
196    return a pointer to value as well as its length in NBYTES.  Return
197    NULL if it was not found.  Note, that the function does not check
198    whether the value fits into the provided buffer. */
199 #ifdef HAVE_OPENSC
200 static const char *
201 find_simple_tlv (const unsigned char *buffer, size_t length,
202                  int tag, size_t *nbytes)
203 {
204   const char *s = buffer;
205   size_t n = length;
206   size_t len;
207     
208   for (;;)
209     {
210       buffer = s;
211       if (n < 2)
212         return NULL; /* buffer too short for tag and length. */
213       len = s[1];
214       s += 2; n -= 2;
215       if (len == 255)
216         {
217           if (n < 2)
218             return NULL; /* we expected 2 more bytes with the length. */
219           len = (s[0] << 8) | s[1];
220           s += 2; n -= 2;
221         }
222       if (*buffer == tag)
223         {
224           *nbytes = len;
225           return s;
226         }
227       if (len > n)
228         return NULL; /* buffer too short to skip to the next tag. */
229       s += len; n -= len;
230     }
231 }
232 #endif /*HAVE_OPENSC*/
233
234 /* Find the ICC Serial Number within the provided BUFFER of LENGTH
235    (which should contain the GDO file) and return it as a hex encoded
236    string and allocated string in SERIAL.  Return an error code when
237    the ICCSN was not found. */
238 #ifdef HAVE_OPENSC
239 static int
240 find_iccsn (const unsigned char *buffer, size_t length, char **serial)
241 {
242   size_t n;
243   const unsigned char *s;
244   char *p;
245
246   s = find_simple_tlv (buffer, length, 0x5A, &n);
247   if (!s)
248     return gpg_error (GPG_ERR_CARD);
249   length -= s - buffer;
250   if (n > length)
251     {
252       /* Oops, it does not fit into the buffer.  This is an invalid
253          encoding (or the buffer is too short.  However, I have some
254          test cards with such an invalid encoding and therefore I use
255          this ugly workaround to return something I can further
256          experiment with. */
257       if (n == 0x0D && length+1 == n)
258         {
259           log_debug ("enabling BMI testcard workaround\n");
260           n--;
261         }
262       else
263         return gpg_error (GPG_ERR_CARD); /* Bad encoding; does
264                                             not fit into buffer. */
265     }
266   if (!n)
267     return gpg_error (GPG_ERR_CARD); /* Well, that is too short. */
268
269   *serial = p = xtrymalloc (2*n+1);
270   if (!*serial)
271     return out_of_core ();
272   for (; n; n--, p += 2, s++)
273     sprintf (p, "%02X", *s);
274   *p = 0;
275   return 0;
276 }
277 #endif /*HAVE_OPENSC*/
278
279 /* Retrieve the serial number and the time of the last update of the
280    card.  The serial number is returned as a malloced string (hex
281    encoded) in SERIAL and the time of update is returned in STAMP.
282    If no update time is available the returned value is 0.  The serial
283    is mandatory for a PKCS_15 application and an error will be
284    returned if this value is not availbale.  For non-PKCS-15 cards a
285    serial number is constructed by other means. Caller must free
286    SERIAL unless the function returns an error. */
287 int 
288 card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
289 {
290 #ifdef HAVE_OPENSC
291   int rc;
292   struct sc_path path;
293   struct sc_file *file;
294   unsigned char buf[256];
295   int buflen;
296 #endif
297
298   if (!card || !serial || !stamp)
299     return gpg_error (GPG_ERR_INV_VALUE);
300
301   *serial = NULL;
302   *stamp = 0; /* not available */
303
304 #ifdef HAVE_OPENSC
305   if (!card->fnc.initialized)
306     {
307       card->fnc.initialized = 1;
308       /* The first use of this card tries to figure out the type of the card 
309          and sets up the function pointers. */
310       rc = sc_pkcs15_bind (card->scard, &card->p15card);
311       if (rc)
312         {
313           if (rc != SC_ERROR_PKCS15_APP_NOT_FOUND)
314             log_error ("binding of existing PKCS-15 failed in reader %d: %s\n",
315                        card->reader, sc_strerror (rc));
316           card->p15card = NULL;
317           rc = 0;
318         }
319       if (card->p15card)
320         card_p15_bind (card);
321       else
322         card_dinsig_bind (card);
323       card->fnc.initialized = 1;
324     }
325       
326
327   /* We should lookup the iso 7812-1 and 8583-3 - argh ISO
328      practice is suppressing innovation - IETF rules!  So we
329      always get the serialnumber from the 2F02 GDO file.  */
330   /* FIXME: in case we can't parse the 2F02 EF and we have a P15 card,
331      we should get the serial number from the respective P15 file */
332   sc_format_path ("3F002F02", &path);
333   rc = sc_select_file (card->scard, &path, &file);
334   if (rc)
335     {
336       log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
337       return gpg_error (GPG_ERR_CARD);
338     }
339   if (file->type != SC_FILE_TYPE_WORKING_EF
340       || file->ef_structure != SC_FILE_EF_TRANSPARENT)
341     {
342       log_error ("wrong type or structure of GDO file\n");
343       sc_file_free (file);
344       return gpg_error (GPG_ERR_CARD);
345     }
346
347   if (!file->size || file->size >= DIM(buf) )
348     { /* FIXME: Use a real parser */
349       log_error ("unsupported size of GDO file (%d)\n", file->size);
350       sc_file_free (file);
351       return gpg_error (GPG_ERR_CARD);
352     }
353   buflen = file->size;
354       
355   rc = sc_read_binary (card->scard, 0, buf, buflen, 0);
356   sc_file_free (file);
357   if (rc < 0) 
358     {
359       log_error ("error reading GDO file: %s\n", sc_strerror (rc));
360       return gpg_error (GPG_ERR_CARD);
361     }
362   if (rc != buflen)
363     {
364       log_error ("short read on GDO file\n");
365       return gpg_error (GPG_ERR_CARD);
366     }
367
368   rc = find_iccsn (buf, buflen, serial);
369   if (gpg_err_code (rc) == GPG_ERR_CARD)
370     log_error ("invalid structure of GDO file\n");
371   if (!rc && card->p15card && !strcmp (*serial, "D27600000000000000000000"))
372     { /* This is a German card with a silly serial number.  Try to get
373          the serial number from the EF(TokenInfo). We indicate such a
374          serial number by the using the prefix: "FF0100". */
375       const char *efser = card->p15card->serial_number;
376       char *p;
377
378       if (!efser)
379         efser = "";
380         
381       xfree (*serial);
382       *serial = NULL;
383       p = xtrymalloc (strlen (efser) + 7);
384       if (!p)
385           rc = out_of_core ();
386       else
387         {
388           strcpy (p, "FF0100");
389           strcpy (p+6, efser);
390           *serial = p;
391         }
392     }
393   else if (!rc && **serial == 'F' && (*serial)[1] == 'F')
394     { /* The serial number starts with our special prefix.  This
395          requires that we put our default prefix "FF0000" in front. */
396       char *p = xtrymalloc (strlen (*serial) + 7);
397       if (!p)
398         {
399           xfree (*serial);
400           *serial = NULL;
401           rc = out_of_core ();
402         }
403       else
404         {
405           strcpy (p, "FF0000");
406           strcpy (p+6, *serial);
407           xfree (*serial);
408           *serial = p;
409         }
410     }
411   return rc;
412 #else
413   return gpg_error (GPG_ERR_NOT_SUPPORTED);
414 #endif
415 }
416
417
418 /* Enumerate all keypairs on the card and return the Keygrip as well
419    as the internal identification of the key.  KEYGRIP must be a
420    caller provided buffer with a size of 20 bytes which will receive
421    the KEYGRIP of the keypair.  If KEYID is not NULL, it returns the
422    ID field of the key in allocated memory; this is a string without
423    spaces.  The function returns -1 when all keys have been
424    enumerated.  Note that the error GPG_ERR_MISSING_CERTIFICATE may be
425    returned if there is just the private key but no public key (ie.e a
426    certificate) available.  Applications might want to continue
427    enumerating after this error.*/
428 int
429 card_enum_keypairs (CARD card, int idx,
430                     unsigned char *keygrip,
431                     char **keyid)
432 {
433   int rc;
434
435   if (keyid)
436     *keyid = NULL;
437
438   if (!card || !keygrip)
439     return gpg_error (GPG_ERR_INV_VALUE);
440   if (idx < 0)
441     return gpg_error (GPG_ERR_INV_INDEX);
442   if (!card->fnc.initialized)
443     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
444   if (!card->fnc.enum_keypairs)
445     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
446   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
447   if (opt.verbose)
448     log_info ("card operation enum_keypairs result: %s\n",
449               gpg_strerror (rc));
450   return rc;
451 }
452
453
454 /* Enumerate all trusted certificates available on the card, return
455    their ID in CERT and the type in CERTTYPE.  Types of certificates
456    are:
457       0   := Unknown
458       100 := Regular X.509 cert
459       101 := Trusted X.509 cert
460       102 := Useful X.509 cert
461  */
462 int
463 card_enum_certs (CARD card, int idx, char **certid, int *certtype)
464 {
465   int rc;
466
467   if (certid)
468     *certid = NULL;
469
470   if (!card)
471     return gpg_error (GPG_ERR_INV_VALUE);
472   if (idx < 0)
473     return gpg_error (GPG_ERR_INV_INDEX);
474   if (!card->fnc.initialized)
475     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
476   if (!card->fnc.enum_certs)
477     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
478   rc = card->fnc.enum_certs (card, idx, certid, certtype);
479   if (opt.verbose)
480     log_info ("card operation enum_certs result: %s\n",
481               gpg_strerror (rc));
482   return rc;
483 }
484
485
486
487 /* Read the certificate identified by CERTIDSTR which is the
488    hexadecimal encoded ID of the certificate, prefixed with the string
489    "3F005015.". The certificate is return in DER encoded form in CERT
490    and NCERT. */
491 int
492 card_read_cert (CARD card, const char *certidstr,
493                 unsigned char **cert, size_t *ncert)
494 {
495   int rc;
496
497   if (!card || !certidstr || !cert || !ncert)
498     return gpg_error (GPG_ERR_INV_VALUE);
499   if (!card->fnc.initialized)
500     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
501   if (!card->fnc.read_cert)
502     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
503   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
504   if (opt.verbose)
505     log_info ("card operation read_cert result: %s\n", gpg_strerror (rc));
506   return rc;
507 }
508
509
510 /* Create the signature and return the allocated result in OUTDATA.
511    If a PIN is required the PINCB will be used to ask for the PIN; it
512    should return the PIN in an allocated buffer and put it into PIN.  */
513 int 
514 card_sign (CARD card, const char *keyidstr, int hashalgo,
515            int (pincb)(void*, const char *, char **),
516            void *pincb_arg,
517            const void *indata, size_t indatalen,
518            unsigned char **outdata, size_t *outdatalen )
519 {
520   int rc;
521
522   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
523     return gpg_error (GPG_ERR_INV_VALUE);
524   if (!card->fnc.initialized)
525     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
526   if (!card->fnc.sign)
527     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
528   rc =  card->fnc.sign (card, keyidstr, hashalgo,
529                         pincb, pincb_arg,
530                         indata, indatalen,
531                         outdata, outdatalen);
532   if (opt.verbose)
533     log_info ("card operation sign result: %s\n", gpg_strerror (rc));
534   return rc;
535 }
536
537
538 /* Create the signature and return the allocated result in OUTDATA.
539    If a PIN is required the PINCB will be used to ask for the PIN; it
540    should return the PIN in an allocated buffer and put it into PIN.  */
541 int 
542 card_decipher (CARD card, const char *keyidstr,
543                int (pincb)(void*, const char *, char **),
544                void *pincb_arg,
545                const void *indata, size_t indatalen,
546                unsigned char **outdata, size_t *outdatalen )
547 {
548   int rc;
549
550   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
551     return gpg_error (GPG_ERR_INV_VALUE);
552   if (!card->fnc.initialized)
553     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
554   if (!card->fnc.decipher)
555     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
556   rc =  card->fnc.decipher (card, keyidstr,
557                             pincb, pincb_arg,
558                             indata, indatalen,
559                             outdata, outdatalen);
560   if (opt.verbose)
561     log_info ("card operation decipher result: %s\n", gpg_strerror (rc));
562   return rc;
563 }
564