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