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