Key generation and signing using the OpenPGP card does rudimentary work.
[gnupg.git] / scd / card-p15.c
1 /* card-p15.c - PKCS-15 based card access
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 #include <ksba.h>
31
32 #include "scdaemon.h"
33 #include "card-common.h"
34
35
36 struct p15private_s {
37   int n_prkey_rsa_objs;
38   struct sc_pkcs15_object *prkey_rsa_objs[32];
39   int n_cert_objs;
40   struct sc_pkcs15_object *cert_objs[32];
41 };
42
43
44 /* Allocate private data. */
45 static int 
46 init_private_data (CARD card)
47 {
48   struct p15private_s *priv;
49   int rc;
50
51   if (card->p15priv)
52     return 0; /* already done. */
53
54   priv = xtrycalloc (1, sizeof *priv);
55   if (!priv)
56     return out_of_core ();
57
58   /* OpenSC (0.7.0) is a bit strange in that the get_objects functions
59      tries to be a bit too clever and implicitly does an enumeration
60      which eventually leads to the fact that every call to this
61      fucntion returns one more macthing object.  The old code in
62      p15_enum_keypairs assume that it would alwyas return the same
63      numer of objects and used this to figure out what the last object
64      enumerated is.  We now do an enum_objects just once and keep it
65      in the private data. */
66   rc = sc_pkcs15_get_objects (card->p15card, SC_PKCS15_TYPE_PRKEY_RSA, 
67                               priv->prkey_rsa_objs,
68                               DIM (priv->prkey_rsa_objs));
69   if (rc < 0) 
70     {
71       log_error ("private keys enumeration failed: %s\n", sc_strerror (rc));
72       xfree (priv);
73       return gpg_error (GPG_ERR_CARD);
74     }
75   priv->n_prkey_rsa_objs = rc;
76
77   /* Read all certificate objects. */
78   rc = sc_pkcs15_get_objects (card->p15card, SC_PKCS15_TYPE_CERT_X509, 
79                               priv->cert_objs,
80                               DIM (priv->cert_objs));
81   if (rc < 0) 
82     {
83       log_error ("private keys enumeration failed: %s\n", sc_strerror (rc));
84       xfree (priv);
85       return gpg_error (GPG_ERR_CARD);
86     }
87   priv->n_cert_objs = rc;
88
89   card->p15priv = priv;
90   return 0;
91 }
92
93
94 /* Release private data used in this module. */
95 void
96 p15_release_private_data (CARD card)
97 {
98   if (!card->p15priv)
99     return;
100   xfree (card->p15priv);
101   card->p15priv = NULL;
102 }
103
104
105
106 /* See card.c for interface description */
107 static int
108 p15_enum_keypairs (CARD card, int idx,
109                    unsigned char *keygrip, char **keyid)
110 {
111   int rc;
112   KsbaError krc;
113   struct p15private_s *priv;
114   struct sc_pkcs15_object *tmpobj;
115   int nobjs;
116   struct sc_pkcs15_prkey_info *pinfo;
117   struct sc_pkcs15_cert_info *certinfo;
118   struct sc_pkcs15_cert      *certder;
119   KsbaCert cert;
120
121   rc = init_private_data (card);
122   if (rc) 
123       return rc;
124   priv = card->p15priv;
125   nobjs = priv->n_prkey_rsa_objs;
126   rc = 0;
127   if (idx >= nobjs)
128     return -1;
129   pinfo = priv->prkey_rsa_objs[idx]->data;
130   
131   /* now we need to read the certificate so that we can calculate the
132      keygrip */
133   rc = sc_pkcs15_find_cert_by_id (card->p15card, &pinfo->id, &tmpobj);
134   if (rc)
135     {
136       log_info ("certificate for private key %d not found: %s\n",
137                 idx, sc_strerror (rc));
138       /* note, that we return the ID anyway */
139       rc = gpg_error (GPG_ERR_MISSING_CERTIFICATE);
140       goto return_keyid;
141     }
142   certinfo = tmpobj->data;
143   rc = sc_pkcs15_read_certificate (card->p15card, certinfo, &certder);
144   if (rc)
145     {
146       log_info ("failed to read certificate for private key %d: %s\n",
147                 idx, sc_strerror (rc));
148       return gpg_error (GPG_ERR_CARD);
149     }
150
151   cert = ksba_cert_new ();
152   if (!cert)
153     {
154       gpg_error_t tmperr = out_of_core ();
155       sc_pkcs15_free_certificate (certder);
156       return tmperr;
157     }
158   krc = ksba_cert_init_from_mem (cert, certder->data, certder->data_len);
159   sc_pkcs15_free_certificate (certder);
160   if (krc)
161     {
162       log_error ("failed to parse the certificate for private key %d: %s\n",
163                  idx, ksba_strerror (krc));
164       ksba_cert_release (cert);
165       return gpg_error (GPG_ERR_CARD);
166     }
167   if (card_help_get_keygrip (cert, keygrip))
168     {
169       log_error ("failed to calculate the keygrip of private key %d\n", idx);
170       ksba_cert_release (cert);
171       return gpg_error (GPG_ERR_CARD);
172     }      
173   ksba_cert_release (cert);
174
175   rc = 0;
176  return_keyid:
177   if (keyid)
178     {
179       char *p;
180       int i;
181
182       *keyid = p = xtrymalloc (9+pinfo->id.len*2+1);
183       if (!*keyid)
184         return out_of_core ();
185       p = stpcpy (p, "P15-5015.");
186       for (i=0; i < pinfo->id.len; i++, p += 2)
187         sprintf (p, "%02X", pinfo->id.value[i]);
188       *p = 0;
189     }
190   
191   return rc;
192 }
193
194 /* See card.c for interface description */
195 static int
196 p15_enum_certs (CARD card, int idx, char **certid, int *type)
197 {
198   int rc;
199   struct p15private_s *priv;
200   struct sc_pkcs15_object *obj;
201   struct sc_pkcs15_cert_info *cinfo;
202   int nobjs;
203
204   rc = init_private_data (card);
205   if (rc) 
206       return rc;
207   priv = card->p15priv;
208   nobjs = priv->n_cert_objs;
209   rc = 0;
210   if (idx >= nobjs)
211     return -1;
212   obj =  priv->cert_objs[idx];
213   cinfo = obj->data;
214   
215   if (certid)
216     {
217       char *p;
218       int i;
219
220       *certid = p = xtrymalloc (9+cinfo->id.len*2+1);
221       if (!*certid)
222         return out_of_core ();
223       p = stpcpy (p, "P15-5015.");
224       for (i=0; i < cinfo->id.len; i++, p += 2)
225         sprintf (p, "%02X", cinfo->id.value[i]);
226       *p = 0;
227     }
228   if (type)
229     {
230       if (!obj->df)
231         *type = 0; /* unknown */
232       else if (obj->df->type == SC_PKCS15_CDF)
233         *type = 100;
234       else if (obj->df->type == SC_PKCS15_CDF_TRUSTED)
235         *type = 101;
236       else if (obj->df->type == SC_PKCS15_CDF_USEFUL)
237         *type = 102;
238       else 
239         *type = 0; /* error -> unknown */
240     }
241   
242   return rc;
243 }
244
245
246 \f
247 static int
248 idstr_to_id (const char *idstr, struct sc_pkcs15_id *id)
249 {
250   const char *s;
251   int n;
252
253   /* For now we only support the standard DF */
254   if (strncmp (idstr, "P15-5015.", 9) ) 
255     return gpg_error (GPG_ERR_INV_ID);
256   for (s=idstr+9, n=0; hexdigitp (s); s++, n++)
257     ;
258   if (*s || (n&1))
259     return gpg_error (GPG_ERR_INV_ID); /*invalid or odd number of digits*/
260   n /= 2;
261   if (!n || n > SC_PKCS15_MAX_ID_SIZE)
262     return gpg_error (GPG_ERR_INV_ID); /* empty or too large */
263   for (s=idstr+9, n=0; *s; s += 2, n++)
264     id->value[n] = xtoi_2 (s);
265   id->len = n;
266   return 0;
267 }
268
269
270 /* See card.c for interface description */
271 static int
272 p15_read_cert (CARD card, const char *certidstr,
273                unsigned char **cert, size_t *ncert)
274 {
275   struct sc_pkcs15_object *tmpobj;
276   struct sc_pkcs15_id certid;
277   struct sc_pkcs15_cert_info *certinfo;
278   struct sc_pkcs15_cert      *certder;
279   int rc;
280
281   if (!card || !certidstr || !cert || !ncert)
282     return gpg_error (GPG_ERR_INV_VALUE);
283   if (!card->p15card)
284     return gpg_error (GPG_ERR_NO_PKCS15_APP);
285
286   rc = idstr_to_id (certidstr, &certid);
287   if (rc)
288     return rc;
289
290   rc = sc_pkcs15_find_cert_by_id (card->p15card, &certid, &tmpobj);
291   if (rc)
292     {
293       log_info ("certificate '%s' not found: %s\n", 
294                 certidstr, sc_strerror (rc));
295       return -1;
296     }
297   certinfo = tmpobj->data;
298   rc = sc_pkcs15_read_certificate (card->p15card, certinfo, &certder);
299   if (rc)
300     {
301       log_info ("failed to read certificate '%s': %s\n",
302                 certidstr, sc_strerror (rc));
303       return gpg_error (GPG_ERR_CARD);
304     }
305
306   *cert = xtrymalloc (certder->data_len);
307   if (!*cert)
308     {
309       gpg_error_t tmperr = out_of_core ();
310       sc_pkcs15_free_certificate (certder);
311       return tmperr;
312     }
313   memcpy (*cert, certder->data, certder->data_len);
314   *ncert = certder->data_len;
315   sc_pkcs15_free_certificate (certder);
316   return 0;
317 }
318
319
320
321
322 \f
323 static int
324 p15_prepare_key (CARD card, const char *keyidstr,
325                  int (pincb)(void*, const char *, char **),
326                  void *pincb_arg, struct sc_pkcs15_object **r_keyobj)
327 {
328   struct sc_pkcs15_id keyid;
329   struct sc_pkcs15_pin_info *pin;
330   struct sc_pkcs15_object *keyobj, *pinobj;
331   char *pinvalue;
332   int rc;
333
334   rc = idstr_to_id (keyidstr, &keyid);
335   if (rc)
336     return rc;
337
338   rc = sc_pkcs15_find_prkey_by_id (card->p15card, &keyid, &keyobj);
339   if (rc < 0)
340     {
341       log_error ("private key not found: %s\n", sc_strerror(rc));
342       return gpg_error (GPG_ERR_NO_SECRET_KEY);
343     }
344
345   rc = sc_pkcs15_find_pin_by_auth_id (card->p15card,
346                                       &keyobj->auth_id, &pinobj);
347   if (rc)
348     {
349       log_error ("failed to find PIN by auth ID: %s\n", sc_strerror (rc));
350       return gpg_error (GPG_ERR_BAD_PIN_METHOD);
351     }
352   pin = pinobj->data;
353
354   /* Fixme: pack this into a verification loop */
355   /* Fixme: we might want to pass pin->min_length and 
356      pin->stored_length */
357   rc = pincb (pincb_arg, pinobj->label, &pinvalue);
358   if (rc)
359     {
360       log_info ("PIN callback returned error: %s\n", gnupg_strerror (rc));
361       return rc;
362     }
363
364   rc = sc_pkcs15_verify_pin (card->p15card, pin,
365                              pinvalue, strlen (pinvalue));
366   xfree (pinvalue);
367   if (rc)
368     {
369       log_info ("PIN verification failed: %s\n", sc_strerror (rc));
370       return gpg_error (GPG_ERR_BAD_PIN);
371     }
372
373   /* fixme: check wheter we need to release KEYOBJ in case of an error */
374   *r_keyobj = keyobj;
375   return 0;
376 }
377
378
379 /* See card.c for interface description */
380 static int 
381 p15_sign (CARD card, const char *keyidstr, int hashalgo,
382           int (pincb)(void*, const char *, char **),
383           void *pincb_arg,
384           const void *indata, size_t indatalen,
385           void **outdata, size_t *outdatalen )
386 {
387   unsigned int cryptflags;
388   struct sc_pkcs15_object *keyobj;
389   int rc;
390   unsigned char *outbuf = NULL;
391   size_t outbuflen;
392
393   if (hashalgo != GCRY_MD_SHA1)
394     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
395
396   rc = p15_prepare_key (card, keyidstr, pincb, pincb_arg, &keyobj);
397   if (rc)
398     return rc;
399
400   cryptflags = SC_ALGORITHM_RSA_PAD_PKCS1;
401
402   outbuflen = 1024; 
403   outbuf = xtrymalloc (outbuflen);
404   if (!outbuf)
405     return out_of_core ();
406   
407   rc = sc_pkcs15_compute_signature (card->p15card, keyobj,
408                                     cryptflags,
409                                     indata, indatalen,
410                                     outbuf, outbuflen );
411   if (rc < 0)
412     {
413       log_error ("failed to create signature: %s\n", sc_strerror (rc));
414       rc = gpg_error (GPG_ERR_CARD);
415     }
416   else
417     {
418       *outdatalen = rc;
419       *outdata = outbuf;
420       outbuf = NULL;
421       rc = 0;
422     }
423
424   xfree (outbuf);
425   return rc;
426 }
427
428
429 /* See card.c for description */
430 static int 
431 p15_decipher (CARD card, const char *keyidstr,
432               int (pincb)(void*, const char *, char **),
433               void *pincb_arg,
434               const void *indata, size_t indatalen,
435               void **outdata, size_t *outdatalen )
436 {
437   struct sc_pkcs15_object *keyobj;
438   int rc;
439   unsigned char *outbuf = NULL;
440   size_t outbuflen;
441
442   rc = p15_prepare_key (card, keyidstr, pincb, pincb_arg, &keyobj);
443   if (rc)
444     return rc;
445
446   if (card && card->scard && card->scard->driver
447       && !strcasecmp (card->scard->driver->short_name, "tcos"))
448     {
449       /* very ugly hack to force the use of a local key.  We need this
450          until we have fixed the initialization code for TCOS cards */
451       struct sc_pkcs15_prkey_info *prkey = keyobj->data;
452       if ( !(prkey->key_reference & 0x80))
453         {
454           prkey->key_reference |= 0x80;
455           log_debug ("using TCOS hack to force the use of local keys\n");
456         }
457       if (*keyidstr && keyidstr[strlen(keyidstr)-1] == '6')
458         {
459           prkey->key_reference |= 1;
460           log_debug ("warning: using even more TCOS hacks\n");
461         }
462     }
463
464   outbuflen = indatalen < 256? 256 : indatalen; 
465   outbuf = xtrymalloc (outbuflen);
466   if (!outbuf)
467     return out_of_core ();
468
469   rc = sc_pkcs15_decipher (card->p15card, keyobj, 
470                            0,
471                            indata, indatalen, 
472                            outbuf, outbuflen); 
473   if (rc < 0)
474     {
475       log_error ("failed to decipher the data: %s\n", sc_strerror (rc));
476       rc = gpg_error (GPG_ERR_CARD);
477     }
478   else
479     {
480       *outdatalen = rc;
481       *outdata = outbuf;
482       outbuf = NULL;
483       rc = 0;
484     }
485
486   xfree (outbuf);
487   return rc;
488 }
489
490
491
492 /* Bind our operations to the card */
493 void
494 card_p15_bind (CARD card)
495 {
496   card->fnc.enum_keypairs = p15_enum_keypairs;
497   card->fnc.enum_certs    = p15_enum_certs;
498   card->fnc.read_cert     = p15_read_cert;
499   card->fnc.sign          = p15_sign;
500   card->fnc.decipher      = p15_decipher;
501 }
502 #endif /*HAVE_OPENSC*/