Added more code fragments.
[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 #include "scdaemon.h"
32
33
34
35 struct card_ctx_s {
36   int reader;   /* used reader */
37   struct sc_context *ctx;
38   struct sc_card *scard;
39   struct sc_pkcs15_card *p15card; /* only if there is a pkcs15 application */
40   
41 };
42
43 /* Map the SC error codes to the GNUPG ones */
44 static int
45 map_sc_err (int rc)
46 {
47   switch (rc)
48     {
49     case 0: rc = 0; break;
50     case SC_ERROR_CMD_TOO_SHORT:         rc = GNUPG_Card_Error; break;
51     case SC_ERROR_CMD_TOO_LONG:          rc = GNUPG_Card_Error; break;
52     case SC_ERROR_NOT_SUPPORTED:         rc = GNUPG_Not_Supported; break;
53     case SC_ERROR_TRANSMIT_FAILED:       rc = GNUPG_Card_Error; break;
54     case SC_ERROR_FILE_NOT_FOUND:        rc = GNUPG_Card_Error; break;
55     case SC_ERROR_INVALID_ARGUMENTS:     rc = GNUPG_Card_Error; break;
56     case SC_ERROR_PKCS15_APP_NOT_FOUND:  rc = GNUPG_No_PKCS15_App; break;
57     case SC_ERROR_REQUIRED_PARAMETER_NOT_FOUND: rc = GNUPG_Card_Error; break;
58     case SC_ERROR_OUT_OF_MEMORY:         rc = GNUPG_Out_Of_Core; break;
59     case SC_ERROR_NO_READERS_FOUND:      rc = GNUPG_Card_Error; break;
60     case SC_ERROR_OBJECT_NOT_VALID:      rc = GNUPG_Card_Error; break;
61     case SC_ERROR_ILLEGAL_RESPONSE:      rc = GNUPG_Card_Error; break;
62     case SC_ERROR_PIN_CODE_INCORRECT:    rc = GNUPG_Card_Error; break;
63     case SC_ERROR_SECURITY_STATUS_NOT_SATISFIED: rc = GNUPG_Card_Error; break;
64     case SC_ERROR_CONNECTING_TO_RES_MGR: rc = GNUPG_Card_Error; break;
65     case SC_ERROR_INVALID_ASN1_OBJECT:   rc = GNUPG_Card_Error; break;
66     case SC_ERROR_BUFFER_TOO_SMALL:      rc = GNUPG_Card_Error; break;
67     case SC_ERROR_CARD_NOT_PRESENT:      rc = GNUPG_Card_Not_Present; break;
68     case SC_ERROR_RESOURCE_MANAGER:      rc = GNUPG_Card_Error; break;
69     case SC_ERROR_CARD_REMOVED:          rc = GNUPG_Card_Removed; break;
70     case SC_ERROR_INVALID_PIN_LENGTH:    rc = GNUPG_Card_Error; break;
71     case SC_ERROR_UNKNOWN_SMARTCARD:     rc = GNUPG_Card_Error; break;
72     case SC_ERROR_UNKNOWN_REPLY:         rc = GNUPG_Card_Error; break;
73     case SC_ERROR_OBJECT_NOT_FOUND:      rc = GNUPG_Card_Error; break;
74     case SC_ERROR_CARD_RESET:            rc = GNUPG_Card_Reset; break;
75     case SC_ERROR_ASN1_OBJECT_NOT_FOUND: rc = GNUPG_Card_Error; break;
76     case SC_ERROR_ASN1_END_OF_CONTENTS:  rc = GNUPG_Card_Error; break;
77     case SC_ERROR_TOO_MANY_OBJECTS:      rc = GNUPG_Card_Error; break;
78     case SC_ERROR_INVALID_CARD:          rc = GNUPG_Invalid_Card; break;
79     case SC_ERROR_WRONG_LENGTH:          rc = GNUPG_Card_Error; break;
80     case SC_ERROR_RECORD_NOT_FOUND:      rc = GNUPG_Card_Error; break;
81     case SC_ERROR_INTERNAL:              rc = GNUPG_Card_Error; break;
82     default: rc = GNUPG_Card_Error; break;
83     }
84   return rc;
85 }
86
87
88 /* Create a new context for the card and figures out some basic
89    information of the card.  Detects whether a PKCS_15 application is
90    stored.
91
92    Common errors: GNUPG_Card_Not_Present */
93 int
94 card_open (CARD *rcard)
95 {
96   CARD card;
97   int rc;
98
99   card = xtrycalloc (1, sizeof *card);
100   if (!card)
101     return GNUPG_Out_Of_Core;
102   card->reader = 0;
103   
104   rc = sc_establish_context (&card->ctx);
105   if (rc)
106     {
107       log_error ("failed to establish SC context: %s\n", sc_strerror (rc));
108       rc = map_sc_err (rc);
109       goto leave;
110     }
111   if (card->reader >= card->ctx->reader_count)
112     {
113       log_error ("no card reader available\n");
114       rc = GNUPG_Card_Error;
115     }
116   card->ctx->error_file = log_get_stream ();
117   card->ctx->debug_file = log_get_stream ();
118   if (sc_detect_card_presence (card->ctx->reader[card->reader], 0) != 1)
119     {
120       rc = GNUPG_Card_Not_Present;
121       goto leave;
122     }
123
124   rc = sc_connect_card (card->ctx->reader[card->reader], 0, &card->scard);
125   if (rc)
126     {
127       log_error ("failed to connect card in reader %d: %s\n",
128                  card->reader, sc_strerror (rc));
129       rc = map_sc_err (rc);
130       goto leave;
131     }
132   if (opt.verbose)
133     log_info ("connected to card in reader %d using driver `%s'\n",
134               card->reader, card->scard->driver->name);
135
136   rc = sc_lock (card->scard);
137   if (rc)
138     {
139       log_error ("can't lock card in reader %d: %s\n",
140                  card->reader, sc_strerror (rc));
141       rc = map_sc_err (rc);
142       goto leave;
143     }
144
145   rc = sc_pkcs15_bind (card->scard, &card->p15card);
146   if (rc == SC_ERROR_PKCS15_APP_NOT_FOUND)
147     rc = 0; /* okay */
148   else if (rc)
149     {
150       log_error ("binding of existing PKCS-15 failed in reader %d: %s\n",
151                  card->reader, sc_strerror (rc));
152       rc = map_sc_err (rc);
153       goto leave;
154     }
155     
156  leave:
157   if (rc)
158     card_close (card);
159   else
160     *rcard = card;
161   return rc;
162 }
163
164
165 /* Close a card and release all resources */
166 void
167 card_close (CARD card)
168 {
169   if (card)
170     {
171       if (card->p15card)
172         {
173           sc_pkcs15_unbind (card->p15card);
174           card->p15card = NULL;
175         }
176       if (card->scard)
177         {
178           sc_unlock (card->scard);
179           sc_disconnect_card (card->scard, 0);
180           card->scard = NULL;
181         }
182       if (card->ctx)
183         {
184           sc_destroy_context (card->ctx);
185           card->ctx = NULL;
186         }
187       xfree (card);
188     }      
189 }
190
191 /* Retrieve the serial number and the time of the last update of the
192    card.  The serial number is returned as a malloced string (hex
193    encoded) in SERIAL and the time of update is returned in STAMP.
194    If no update time is available the returned value is 0.  The serial
195    is mandatory for a PKCS_15 application and an error will be
196    returned if this value is not availbale.  For non-PKCS-15 cards a
197    serial number is constructed by other means. Caller must free
198    SERIAL unless the fucntion returns an error. */
199 int 
200 card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
201 {
202   char *s;
203
204   if (!card || !serial || !stamp)
205     return GNUPG_Invalid_Value;
206
207   *serial = NULL;
208   *stamp = 0; /* not available */
209   if (!card->p15card)
210     { /* fixme: construct a serial number */
211       /* We should lookup the iso 7812-1 and 8583-3 - argh ISO practice is
212          suppressing innovation - IETF rules! */
213       return GNUPG_No_PKCS15_App;
214     }
215   s = card->p15card->serial_number;
216   if (!s || !hexdigitp (s) )
217     return GNUPG_Invalid_Card; /* the serial number is mandatory */
218   *serial = xstrdup (s);
219   if (!*serial)
220     return GNUPG_Out_Of_Core;
221   return 0;
222 }
223
224
225 \f
226 /* Get the keygrip from CERT, return 0 on success */
227 static int
228 get_keygrip (KsbaCert cert, unsigned char *array)
229 {
230   GCRY_SEXP s_pkey;
231   int rc;
232   KsbaSexp p;
233   size_t n;
234   
235   p = ksba_cert_get_public_key (cert);
236   if (!p)
237     return -1; /* oops */
238   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
239   if (!n)
240     return -1; /* libksba did not return a proper S-expression */
241   rc = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
242   xfree (p);
243   if (rc)
244     return -1; /* can't parse that S-expression */
245   array = gcry_pk_get_keygrip (s_pkey, array);
246   gcry_sexp_release (s_pkey);
247   if (!array)
248     return -1; /* failed to calculate the keygrip */
249   return 0;
250 }
251
252
253
254 /* Enumerate all keypairs on the card and return the Keygrip as well
255    as the internal identification of the key.  KEYGRIP must be a
256    caller provided buffer with a size of 20 bytes which will receive
257    the KEYGRIP of the keypair.  If KEYID is not NULL, it returns the
258    ID field of the key in allocated memory, NKEYID will then receive
259    the length of it.  The function returns -1 when all keys have been
260    enumerated.  Note that the error GNUPG_Missing_Certificate may be
261    returned if there is just the private key but no public key (ie.e a
262    certificate) available.  Applications might want to continue
263    enumerating after this error.*/
264 int
265 card_enum_keypairs (CARD card, int idx,
266                     unsigned char *keygrip,
267                     unsigned char **keyid, size_t *nkeyid)
268 {
269   int rc;
270   KsbaError krc;
271   struct sc_pkcs15_prkey_info *pinfo;
272   struct sc_pkcs15_cert_info *certinfo;
273   struct sc_pkcs15_cert      *certder;
274   KsbaCert cert;
275
276   if (keyid)
277     *keyid = NULL;
278   if (nkeyid)
279     *nkeyid = 0;
280
281   if (!card || !keygrip || !card->p15card)
282     return GNUPG_Invalid_Value;
283   if (idx < 0)
284     return GNUPG_Invalid_Index;
285         
286   rc = sc_pkcs15_enum_private_keys (card->p15card);
287   if (rc < 0) 
288     {
289       log_error ("sc_pkcs15_enum_private_keys failed: %s\n", sc_strerror (rc));
290       return GNUPG_Card_Error;
291     }
292   if ( idx >= card->p15card->prkey_count)
293     return -1;
294   pinfo = card->p15card->prkey_info + idx;
295   
296   /* now we need to read the certificate so that we can calculate the
297      keygrip */
298   rc = sc_pkcs15_find_cert_by_id (card->p15card, &pinfo->id, &certinfo);
299   if (rc)
300     {
301       log_info ("certificate for private key %d not found: %s\n",
302                 idx, sc_strerror (rc));
303       /* but we should return the ID anyway */
304       if (keyid)
305         {
306           *keyid = xtrymalloc (pinfo->id.len);
307           if (!*keyid)
308             return GNUPG_Out_Of_Core;
309           memcpy (*keyid, pinfo->id.value, pinfo->id.len);
310         }
311       if (nkeyid)
312         *nkeyid = pinfo->id.len;
313       return GNUPG_Missing_Certificate;
314     }
315   rc = sc_pkcs15_read_certificate (card->p15card, certinfo, &certder);
316   if (rc)
317     {
318       log_info ("failed to read certificate for private key %d: %s\n",
319                 idx, sc_strerror (rc));
320       return GNUPG_Card_Error;
321     }
322
323   cert = ksba_cert_new ();
324   if (!cert)
325     {
326       sc_pkcs15_free_certificate (certder);
327       return GNUPG_Out_Of_Core;
328     }
329   krc = ksba_cert_init_from_mem (cert, certder->data, certder->data_len);
330   sc_pkcs15_free_certificate (certder);
331   if (krc)
332     {
333       log_error ("failed to parse the certificate for private key %d: %s\n",
334                  idx, ksba_strerror (krc));
335       ksba_cert_release (cert);
336       return GNUPG_Card_Error;
337     }
338   if (get_keygrip (cert, keygrip))
339     {
340       log_error ("failed to calculate the keygrip of private key %d\n", idx);
341       ksba_cert_release (cert);
342       return GNUPG_Card_Error;
343     }      
344   ksba_cert_release (cert);
345
346   /* return the iD */
347   if (keyid)
348     {
349       *keyid = xtrymalloc (pinfo->id.len);
350       if (!*keyid)
351         return GNUPG_Out_Of_Core;
352       memcpy (*keyid, pinfo->id.value, pinfo->id.len);
353     }
354   if (nkeyid)
355     *nkeyid = pinfo->id.len;
356   
357   return 0;
358 }
359
360
361 \f
362 static int
363 idstr_to_id (const char *idstr, struct sc_pkcs15_id *id)
364 {
365   const char *s;
366   int n;
367
368   /* For now we only support the standard DF */
369   if (strncmp (idstr, "3F005015.", 9) ) 
370     return GNUPG_Invalid_Id;
371   for (s=idstr+9, n=0; hexdigitp (s); s++, n++)
372     ;
373   if (*s || (n&1))
374     return GNUPG_Invalid_Id; /* invalid or odd number of digits */
375   n /= 2;
376   if (!n || n > SC_PKCS15_MAX_ID_SIZE)
377     return GNUPG_Invalid_Id; /* empty or too large */
378   for (s=idstr+9, n=0; *s; s += 2, n++)
379     id->value[n] = xtoi_2 (s);
380   id->len = n;
381   return 0;
382 }
383
384 /* Read the certificate identified by CERTIDSTR which is the
385    hexadecimal encoded ID of the certificate, prefixed with the string
386    "3F005015.". The certificate is return in DER encoded form in CERT
387    and NCERT. */
388 int
389 card_read_cert (CARD card, const char *certidstr,
390                 unsigned char **cert, size_t *ncert)
391 {
392   struct sc_pkcs15_id certid;
393   struct sc_pkcs15_cert_info *certinfo;
394   struct sc_pkcs15_cert      *certder;
395   int rc;
396
397   if (!card || !certidstr || !card->p15card || !cert || !ncert)
398     return GNUPG_Invalid_Value;
399
400   rc = idstr_to_id (certidstr, &certid);
401   if (rc)
402     return rc;
403
404   rc = sc_pkcs15_find_cert_by_id (card->p15card, &certid, &certinfo);
405   if (rc)
406     {
407       log_info ("certificate '%s' not found: %s\n", 
408                 certidstr, sc_strerror (rc));
409       return -1;
410     }
411   rc = sc_pkcs15_read_certificate (card->p15card, certinfo, &certder);
412   if (rc)
413     {
414       log_info ("failed to read certificate '%s': %s\n",
415                 certidstr, sc_strerror (rc));
416       return GNUPG_Card_Error;
417     }
418
419   *cert = xtrymalloc (certder->data_len);
420   if (!*cert)
421     {
422       sc_pkcs15_free_certificate (certder);
423       return GNUPG_Out_Of_Core;
424     }
425   memcpy (*cert, certder->data, certder->data_len);
426   *ncert = certder->data_len;
427   sc_pkcs15_free_certificate (certder);
428   return 0;
429 }
430
431
432 \f
433 /* Create the signature and return the allocated result in OUTDATA. */
434 int 
435 card_create_signature (CARD card, const char *keyidstr, int hashalgo,
436                        const void *indata, size_t indatalen,
437                        void **outdata, size_t *outdatalen )
438 {
439   unsigned int cryptflags = 0;
440   struct sc_pkcs15_id keyid;
441   struct sc_pkcs15_prkey_info *key;
442   /*  struct sc_pkcs15_pin_info *pin;*/
443   int rc;
444   unsigned char *outbuf = NULL;
445   size_t outbuflen;
446
447   if (!card || !card->p15card || !indata || !indatalen
448       || !outdata || !outdatalen)
449     return GNUPG_Invalid_Value;
450   
451   if (hashalgo != GCRY_MD_SHA1)
452     return GNUPG_Unsupported_Algorithm;
453
454   rc = idstr_to_id (keyidstr, &keyid);
455   if (rc)
456     return rc;
457
458   rc = sc_pkcs15_find_prkey_by_id (card->p15card, &keyid, &key);
459   if (rc < 0)
460     {
461       log_error ("private key not found: %s\n", sc_strerror(rc));
462       rc = GNUPG_No_Secret_Key;
463       goto leave;
464     }
465   rc = 0;
466   key = card->p15card->prkey_info;
467
468
469   /* FIXME: Handle PIN via callback */
470
471   cryptflags |= SC_PKCS15_HASH_SHA1;
472   cryptflags |= SC_PKCS15_PAD_PKCS1_V1_5;
473
474   outbuflen = 1024; 
475   outbuf = xtrymalloc (outbuflen);
476   if (!outbuf)
477     return GNUPG_Out_Of_Core;
478   
479   rc = sc_pkcs15_compute_signature (card->p15card, key,
480                                     cryptflags,
481                                     indata, indatalen,
482                                     outbuf, outbuflen );
483   if (rc < 0)
484     {
485       log_error ("failed to create signature: %s\n", sc_strerror (rc));
486       rc = GNUPG_Card_Error;
487     }
488   else
489     {
490       *outdatalen = rc;
491       *outdata = outbuf;
492       outbuf = NULL;
493       rc = 0;
494     }
495
496
497
498 leave:
499   xfree (outbuf);
500   return rc;
501 }
502
503