629e2936be523b99a9b47455b918c3a369d6eb13
[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 #include <opensc-pkcs15.h>
29 #include <ksba.h>
30
31 #if SC_MAX_SEC_ATTR_SIZE < 36
32 # error This is not the patched OpenSC version
33 #endif
34
35 #include "scdaemon.h"
36 #include "card-common.h"
37
38 /* Map the SC error codes to the GNUPG ones */
39 int
40 map_sc_err (int rc)
41 {
42   switch (rc)
43     {
44     case 0: rc = 0; break;
45     case SC_ERROR_CMD_TOO_SHORT:         rc = GNUPG_Card_Error; break;
46     case SC_ERROR_CMD_TOO_LONG:          rc = GNUPG_Card_Error; break;
47     case SC_ERROR_NOT_SUPPORTED:         rc = GNUPG_Not_Supported; break;
48     case SC_ERROR_TRANSMIT_FAILED:       rc = GNUPG_Card_Error; break;
49     case SC_ERROR_FILE_NOT_FOUND:        rc = GNUPG_Card_Error; break;
50     case SC_ERROR_INVALID_ARGUMENTS:     rc = GNUPG_Card_Error; break;
51     case SC_ERROR_PKCS15_APP_NOT_FOUND:  rc = GNUPG_No_PKCS15_App; break;
52     case SC_ERROR_REQUIRED_PARAMETER_NOT_FOUND: rc = GNUPG_Card_Error; break;
53     case SC_ERROR_OUT_OF_MEMORY:         rc = GNUPG_Out_Of_Core; break;
54     case SC_ERROR_NO_READERS_FOUND:      rc = GNUPG_Card_Error; break;
55     case SC_ERROR_OBJECT_NOT_VALID:      rc = GNUPG_Card_Error; break;
56     case SC_ERROR_ILLEGAL_RESPONSE:      rc = GNUPG_Card_Error; break;
57     case SC_ERROR_PIN_CODE_INCORRECT:    rc = GNUPG_Card_Error; break;
58     case SC_ERROR_SECURITY_STATUS_NOT_SATISFIED: rc = GNUPG_Card_Error; break;
59     case SC_ERROR_CONNECTING_TO_RES_MGR: rc = GNUPG_Card_Error; break;
60     case SC_ERROR_INVALID_ASN1_OBJECT:   rc = GNUPG_Card_Error; break;
61     case SC_ERROR_BUFFER_TOO_SMALL:      rc = GNUPG_Card_Error; break;
62     case SC_ERROR_CARD_NOT_PRESENT:      rc = GNUPG_Card_Not_Present; break;
63     case SC_ERROR_RESOURCE_MANAGER:      rc = GNUPG_Card_Error; break;
64     case SC_ERROR_CARD_REMOVED:          rc = GNUPG_Card_Removed; break;
65     case SC_ERROR_INVALID_PIN_LENGTH:    rc = GNUPG_Card_Error; break;
66     case SC_ERROR_UNKNOWN_SMARTCARD:     rc = GNUPG_Card_Error; break;
67     case SC_ERROR_UNKNOWN_REPLY:         rc = GNUPG_Card_Error; break;
68     case SC_ERROR_OBJECT_NOT_FOUND:      rc = GNUPG_Card_Error; break;
69     case SC_ERROR_CARD_RESET:            rc = GNUPG_Card_Reset; break;
70     case SC_ERROR_ASN1_OBJECT_NOT_FOUND: rc = GNUPG_Card_Error; break;
71     case SC_ERROR_ASN1_END_OF_CONTENTS:  rc = GNUPG_Card_Error; break;
72     case SC_ERROR_TOO_MANY_OBJECTS:      rc = GNUPG_Card_Error; break;
73     case SC_ERROR_INVALID_CARD:          rc = GNUPG_Invalid_Card; break;
74     case SC_ERROR_WRONG_LENGTH:          rc = GNUPG_Card_Error; break;
75     case SC_ERROR_RECORD_NOT_FOUND:      rc = GNUPG_Card_Error; break;
76     case SC_ERROR_INTERNAL:              rc = GNUPG_Card_Error; break;
77     default: rc = GNUPG_Card_Error; break;
78     }
79   return rc;
80 }
81
82 /* Get the keygrip from CERT, return 0 on success */
83 int
84 card_help_get_keygrip (KsbaCert cert, unsigned char *array)
85 {
86   GCRY_SEXP s_pkey;
87   int rc;
88   KsbaSexp p;
89   size_t n;
90   
91   p = ksba_cert_get_public_key (cert);
92   if (!p)
93     return -1; /* oops */
94   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
95   if (!n)
96     return -1; /* libksba did not return a proper S-expression */
97   rc = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
98   xfree (p);
99   if (rc)
100     return -1; /* can't parse that S-expression */
101   array = gcry_pk_get_keygrip (s_pkey, array);
102   gcry_sexp_release (s_pkey);
103   if (!array)
104     return -1; /* failed to calculate the keygrip */
105   return 0;
106 }
107
108
109
110
111
112
113 \f
114 /* Create a new context for the card and figures out some basic
115    information of the card.  Detects whgether a PKCS_15 application is
116    stored.
117
118    Common errors: GNUPG_Card_Not_Present */
119 int
120 card_open (CARD *rcard)
121 {
122   CARD card;
123   int rc;
124
125   card = xtrycalloc (1, sizeof *card);
126   if (!card)
127     return GNUPG_Out_Of_Core;
128   card->reader = 0;
129   
130   rc = sc_establish_context (&card->ctx, "scdaemon");
131   if (rc)
132     {
133       log_error ("failed to establish SC context: %s\n", sc_strerror (rc));
134       rc = map_sc_err (rc);
135       goto leave;
136     }
137   if (card->reader >= card->ctx->reader_count)
138     {
139       log_error ("no card reader available\n");
140       rc = GNUPG_Card_Error;
141       goto leave;
142     }
143   card->ctx->error_file = log_get_stream ();
144   if (opt.debug)
145     {
146        card->ctx->debug_file = log_get_stream ();
147     }
148   if (sc_detect_card_presence (card->ctx->reader[card->reader], 0) != 1)
149     {
150       rc = GNUPG_Card_Not_Present;
151       goto leave;
152     }
153
154   rc = sc_connect_card (card->ctx->reader[card->reader], 0, &card->scard);
155   if (rc)
156     {
157       log_error ("failed to connect card in reader %d: %s\n",
158                  card->reader, sc_strerror (rc));
159       rc = map_sc_err (rc);
160       goto leave;
161     }
162   if (opt.verbose)
163     log_info ("connected to card in reader %d using driver `%s'\n",
164               card->reader, card->scard->driver->name);
165
166   rc = sc_lock (card->scard);
167   if (rc)
168     {
169       log_error ("can't lock card in reader %d: %s\n",
170                  card->reader, sc_strerror (rc));
171       rc = map_sc_err (rc);
172       goto leave;
173     }
174
175     
176  leave:
177   if (rc)
178     card_close (card);
179   else
180     *rcard = card;
181   return rc;
182 }
183
184
185 /* Close a card and release all resources */
186 void
187 card_close (CARD card)
188 {
189   if (card)
190     {
191       if (card->p15card)
192         {
193           sc_pkcs15_unbind (card->p15card);
194           card->p15card = NULL;
195         }
196       if (card->scard)
197         {
198           sc_unlock (card->scard);
199           sc_disconnect_card (card->scard, 0);
200           card->scard = NULL;
201         }
202       if (card->ctx)
203         {
204           sc_release_context (card->ctx);
205           card->ctx = NULL;
206         }
207       xfree (card);
208     }      
209 }
210
211
212
213 /* Retrieve the serial number and the time of the last update of the
214    card.  The serial number is returned as a malloced string (hex
215    encoded) in SERIAL and the time of update is returned in STAMP.
216    If no update time is available the returned value is 0.  The serial
217    is mandatory for a PKCS_15 application and an error will be
218    returned if this value is not availbale.  For non-PKCS-15 cards a
219    serial number is constructed by other means. Caller must free
220    SERIAL unless the function returns an error. */
221 int 
222 card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
223 {
224   char *s;
225   int rc;
226   struct sc_path path;
227   struct sc_file *file;
228   unsigned char buf[12];
229   int i;
230
231   if (!card || !serial || !stamp)
232     return GNUPG_Invalid_Value;
233
234   *serial = NULL;
235   *stamp = 0; /* not available */
236
237   if (!card->fnc.initialized)
238     {
239       card->fnc.initialized = 1;
240       /* The first use of this card tries to figure out the type of the card 
241          and sets up the function pointers. */
242       rc = sc_pkcs15_bind (card->scard, &card->p15card);
243       if (rc)
244         {
245           if (rc != SC_ERROR_PKCS15_APP_NOT_FOUND)
246             log_error ("binding of existing PKCS-15 failed in reader %d: %s\n",
247                        card->reader, sc_strerror (rc));
248           card->p15card = NULL;
249           rc = 0;
250         }
251       if (card->p15card)
252         card_p15_bind (card);
253       else
254         card_dinsig_bind (card);
255       card->fnc.initialized = 1;
256     }
257       
258
259   /* We should lookup the iso 7812-1 and 8583-3 - argh ISO
260      practice is suppressing innovation - IETF rules!  So we
261      always get the serialnumber from the 2F00 GDO file.  */
262   sc_format_path ("3F002F02", &path);
263   rc = sc_select_file (card->scard, &path, &file);
264   if (rc)
265     {
266       log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
267       return GNUPG_Card_Error;
268     }
269   if (file->type != SC_FILE_TYPE_WORKING_EF
270       || file->ef_structure != SC_FILE_EF_TRANSPARENT)
271     {
272       log_error ("wrong type or structure of GDO file\n");
273       sc_file_free (file);
274       return GNUPG_Card_Error;
275     }
276   if (file->size != 12)
277     { /* FIXME: Use a real parser */
278       log_error ("unsupported size of GDO file\n");
279       sc_file_free (file);
280       return GNUPG_Card_Error;
281     }
282       
283   rc = sc_read_binary (card->scard, 0, buf, DIM (buf), 0);
284   sc_file_free (file);
285   if (rc < 0) 
286     {
287       log_error ("error reading GDO file: %s\n", sc_strerror (rc));
288       return GNUPG_Card_Error;
289     }
290   if (rc != file->size)
291     {
292       log_error ("short read on GDO file\n");
293       return GNUPG_Card_Error;
294     }
295   if (buf[0] != 0x5a || buf[1] != 10)
296     {
297       log_error ("invalid structure of GDO file\n");
298       return GNUPG_Card_Error;
299     }
300   *serial = s = xtrymalloc (21);
301   if (!*serial)
302     return GNUPG_Out_Of_Core;
303   for (i=0; i < 10; i++, s += 2)
304     sprintf (s, "%02X", buf[2+i]);
305   return 0;
306 }
307
308
309 /* Enumerate all keypairs on the card and return the Keygrip as well
310    as the internal identification of the key.  KEYGRIP must be a
311    caller provided buffer with a size of 20 bytes which will receive
312    the KEYGRIP of the keypair.  If KEYID is not NULL, it returns the
313    ID field of the key in allocated memory; this is a string without
314    spaces.  The function returns -1 when all keys have been
315    enumerated.  Note that the error GNUPG_Missing_Certificate may be
316    returned if there is just the private key but no public key (ie.e a
317    certificate) available.  Applications might want to continue
318    enumerating after this error.*/
319 int
320 card_enum_keypairs (CARD card, int idx,
321                     unsigned char *keygrip,
322                     char **keyid)
323 {
324   int rc;
325
326   if (keyid)
327     *keyid = NULL;
328
329   if (!card || !keygrip)
330     return GNUPG_Invalid_Value;
331   if (idx < 0)
332     return GNUPG_Invalid_Index;
333   if (!card->fnc.initialized)
334     return GNUPG_Card_Not_Initialized;
335   if (!card->fnc.enum_keypairs)
336     return GNUPG_Unsupported_Operation;
337   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
338   if (opt.verbose)
339     log_info ("card operation enum_keypairs result: %s\n",
340               gnupg_strerror (rc));
341   return rc;
342 }
343
344
345 /* Read the certificate identified by CERTIDSTR which is the
346    hexadecimal encoded ID of the certificate, prefixed with the string
347    "3F005015.". The certificate is return in DER encoded form in CERT
348    and NCERT. */
349 int
350 card_read_cert (CARD card, const char *certidstr,
351                 unsigned char **cert, size_t *ncert)
352 {
353   int rc;
354
355   if (!card || !certidstr || !cert || !ncert)
356     return GNUPG_Invalid_Value;
357   if (!card->fnc.initialized)
358     return GNUPG_Card_Not_Initialized;
359   if (!card->fnc.read_cert)
360     return GNUPG_Unsupported_Operation;
361   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
362   if (opt.verbose)
363     log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
364   return rc;
365 }
366
367
368 /* Create the signature and return the allocated result in OUTDATA.
369    If a PIN is required the PINCB will be used to ask for the PIN; it
370    should return the PIN in an allocated buffer and put it into PIN.  */
371 int 
372 card_sign (CARD card, const char *keyidstr, int hashalgo,
373            int (pincb)(void*, const char *, char **),
374            void *pincb_arg,
375            const void *indata, size_t indatalen,
376            void **outdata, size_t *outdatalen )
377 {
378   int rc;
379
380   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
381     return GNUPG_Invalid_Value;
382   if (!card->fnc.initialized)
383     return GNUPG_Card_Not_Initialized;
384   if (!card->fnc.sign)
385     return GNUPG_Unsupported_Operation;
386   rc =  card->fnc.sign (card, keyidstr, hashalgo,
387                         pincb, pincb_arg,
388                         indata, indatalen,
389                         outdata, outdatalen);
390   if (opt.verbose)
391     log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
392   return rc;
393 }
394
395
396 /* Create the signature and return the allocated result in OUTDATA.
397    If a PIN is required the PINCB will be used to ask for the PIN; it
398    should return the PIN in an allocated buffer and put it into PIN.  */
399 int 
400 card_decipher (CARD card, const char *keyidstr,
401                int (pincb)(void*, const char *, char **),
402                void *pincb_arg,
403                const void *indata, size_t indatalen,
404                void **outdata, size_t *outdatalen )
405 {
406   int rc;
407
408   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
409     return GNUPG_Invalid_Value;
410   if (!card->fnc.initialized)
411     return GNUPG_Card_Not_Initialized;
412   if (!card->fnc.decipher)
413     return GNUPG_Unsupported_Operation;
414   rc =  card->fnc.decipher (card, keyidstr,
415                             pincb, pincb_arg,
416                             indata, indatalen,
417                             outdata, outdatalen);
418   if (opt.verbose)
419     log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
420   return rc;
421 }