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