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