* keydb.c (keydb_add_resource): Create keybox
[gnupg.git] / sm / sign.c
1 /* sign.c - Sign a message
2  *      Copyright (C) 2001 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 <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h> 
27 #include <time.h>
28 #include <assert.h>
29
30 #include <gcrypt.h>
31 #include <ksba.h>
32
33 #include "gpgsm.h"
34 #include "keydb.h"
35 #include "i18n.h"
36
37
38
39
40 struct reader_cb_parm_s {
41   FILE *fp;
42 };
43
44
45
46 static void
47 hash_data (int fd, GCRY_MD_HD md)
48 {
49   FILE *fp;
50   char buffer[4096];
51   int nread;
52
53   fp = fdopen ( dup (fd), "rb");
54   if (!fp)
55     {
56       log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
57       return;
58     }
59
60   do 
61     {
62       nread = fread (buffer, 1, DIM(buffer), fp);
63       gcry_md_write (md, buffer, nread);
64     }
65   while (nread);
66   if (ferror (fp))
67       log_error ("read error on fd %d: %s\n", fd, strerror (errno));
68   fclose (fp);
69 }
70
71
72 static KsbaCert
73 get_default_signer (void)
74 {
75   const char key[] = "1.2.840.113549.1.9.1=#7472757374407765622E6465#,CN=WEB.DE TrustCenter,OU=TrustCenter,O=WEB.DE AG,L=D-76227 Karlsruhe,C=DE";
76   KsbaCert cert = NULL;
77   KEYDB_HANDLE kh = NULL;
78   int rc;
79
80   kh = keydb_new (0);
81   if (!kh)
82     return NULL;
83
84   rc = keydb_search_subject (kh, key);
85   if (rc)
86     {
87       log_debug ("failed to find default certificate: rc=%d\n", rc);
88     }
89   else 
90     {
91       rc = keydb_get_cert (kh, &cert);
92       if (rc)
93         {
94           log_debug ("failed to get cert: rc=%d\n", rc);
95         }
96     }
97
98   keydb_release (kh);
99   return cert;
100 }
101
102
103 \f
104 /* Perform a sign operation.  
105
106    Sign the data received on DATA-FD in embedded mode or in deatched
107    mode when DETACHED is true.  Write the signature to OUT_FP The key
108    used to sign is the default - we will extend the fucntion to take a
109    list of fingerprints in the future. */
110 int
111 gpgsm_sign (CTRL ctrl, int data_fd, int detached, FILE *out_fp)
112 {
113   int i, rc;
114   KsbaError err;
115   KsbaWriter writer = NULL;
116   KsbaCMS cms = NULL;
117   KsbaStopReason stopreason;
118   KsbaCert cert;
119   KEYDB_HANDLE kh = NULL;
120   GCRY_MD_HD data_md = NULL;
121   struct reader_cb_parm_s rparm;
122   int signer;
123   const char *algoid;
124   int algo;
125
126   memset (&rparm, 0, sizeof rparm);
127
128   if (!detached)
129     {
130        rc = seterr (Not_Implemented);
131        goto leave;
132     }
133
134
135   kh = keydb_new (0);
136   if (!kh)
137     {
138       log_error (_("failed to allocated keyDB handle\n"));
139       rc = GNUPG_General_Error;
140       goto leave;
141     }
142
143   rparm.fp = fdopen ( dup (data_fd), "rb");
144   if (!rparm.fp)
145     {
146       log_error ("fdopen() failed: %s\n", strerror (errno));
147       rc = seterr (IO_Error);
148       goto leave;
149     }
150
151   writer = ksba_writer_new ();
152   if (!writer)
153     {
154       rc = seterr (Out_Of_Core);
155       goto leave;
156     }
157   rc = ksba_writer_set_file (writer, out_fp);
158   if (rc)
159     {
160       ksba_writer_release (writer);
161       rc = map_ksba_err (rc);
162       goto leave;
163     }
164
165   cms = ksba_cms_new ();
166   if (!cms)
167     {
168       rc = seterr (Out_Of_Core);
169       goto leave;
170     }
171
172   err = ksba_cms_set_reader_writer (cms, NULL, writer);
173   if (err)
174     {
175       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
176                  ksba_strerror (err));
177       rc = map_ksba_err (err);
178       goto leave;
179     }
180
181   /* We are going to create signed data with data as encap. content */
182   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_SIGNED_DATA);
183   if (!err)
184     err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
185   if (err)
186     {
187       log_debug ("ksba_cms_set_content_type failed: %s\n",
188                  ksba_strerror (err));
189       rc = map_ksba_err (err);
190       goto leave;
191     }
192
193
194   /* gather certificates of signers  and store in theCMS object */
195   /* fixme: process a list of fingerprints and store the certificate of
196      each given fingerprint */
197   cert = get_default_signer ();
198   if (!cert)
199     {
200       log_error ("no default signer found\n");
201       rc = seterr (General_Error);
202       goto leave;
203     }
204   err = ksba_cms_add_signer (cms, cert);
205   if (err)
206     {
207       log_debug ("ksba_cms_add_signer failed: %s\n",  ksba_strerror (err));
208       rc = map_ksba_err (err);
209       goto leave;
210     }
211   cert = NULL; /* cms does now own the certificate */
212
213   /* fixme: We might want to include a list of certificate which are
214      put as info into the signed data object - maybe we should add a
215      flag to ksba_cms_add_signer to decider whether this cert should
216      be send along with the signature */
217   
218   /* Set the hash algorithm we are going to use */
219   err = ksba_cms_add_digest_algo (cms, "1.3.14.3.2.26" /*SHA-1*/);
220   if (err)
221     {
222       log_debug ("ksba_cms_add_digest_algo failed: %s\n", ksba_strerror (err));
223       rc = map_ksba_err (err);
224       goto leave;
225     }
226
227   /* Prepare hashing (actually we are figuring out what we have set above)*/
228   data_md = gcry_md_open (0, 0);
229   if (!data_md)
230     {
231       rc = map_gcry_err (gcry_errno());
232       log_error ("md_open failed: %s\n", gcry_strerror (-1));
233       goto leave;
234     }
235   for (i=0; (algoid=ksba_cms_get_digest_algo_list (cms, i)); i++)
236     {
237       algo = gcry_md_map_name (algoid);
238       if (!algo)
239         {
240           log_error ("unknown hash algorithm `%s'\n", algoid? algoid:"?");
241           rc = GNUPG_Bug;
242           goto leave;
243         }
244       gcry_md_enable (data_md, algo);
245     }
246
247   signer = 0;
248   if (detached)
249     { /* we hash the data right now so that we can store the message
250          digest.  ksba_cms_build() takes this as an flag that detached
251          data is expected. */
252       unsigned char *digest;
253       size_t digest_len;
254       /* Fixme do this for all signers and get the algo to use from
255          the signer's certificate - does not make mich sense, bu we
256          should do this consistent as we have already done it above */
257       algo = GCRY_MD_SHA1; 
258       hash_data (data_fd, data_md);
259       digest = gcry_md_read (data_md, algo);
260       digest_len = gcry_md_get_algo_dlen (algo);
261       if ( !digest || !digest_len)
262         {
263           log_error ("problem getting the hash of the data\n");
264           rc = GNUPG_Bug;
265           goto leave;
266         }
267       err = ksba_cms_set_message_digest (cms, signer, digest, digest_len);
268       if (err)
269         {
270           log_error ("ksba_cms_set_message_digest failed: %s\n",
271                      ksba_strerror (err));
272           rc = map_ksba_err (err);
273           goto leave;
274         }
275     }
276
277   err = ksba_cms_set_signing_time (cms, signer, 0 /*now*/);
278   if (err)
279     {
280       log_error ("ksba_cms_set_signing_time failed: %s\n",
281                  ksba_strerror (err));
282       rc = map_ksba_err (err);
283       goto leave;
284     }
285
286   do 
287     {
288       err = ksba_cms_build (cms, &stopreason);
289       if (err)
290         {
291           log_debug ("ksba_cms_build failed: %s\n", ksba_strerror (err));
292           rc = map_ksba_err (err);
293           goto leave;
294         }
295       log_debug ("ksba_cms_build - stop reason %d\n", stopreason);
296
297       if (stopreason == KSBA_SR_BEGIN_DATA)
298         { /* hash the data and store the message digest */
299           assert (!detached);
300         }
301       else if (stopreason == KSBA_SR_NEED_SIG)
302         { /* calculate the signature for all signers */
303           GCRY_MD_HD md;
304
305           algo = GCRY_MD_SHA1;
306           signer = 0;
307           md = gcry_md_open (algo, 0);
308           if (!md)
309             {
310               log_error ("md_open failed: %s\n", gcry_strerror (-1));
311               goto leave;
312             }
313           ksba_cms_set_hash_function (cms, HASH_FNC, md);
314           rc = ksba_cms_hash_signed_attrs (cms, signer);
315           if (rc)
316             {
317               log_debug ("hashing signed attrs failed: %s\n",
318                          ksba_strerror (rc));
319               gcry_md_close (md);
320               goto leave;
321             }
322           
323           { /* This is all an temporary hack */
324             char *sigval;
325
326             cert = get_default_signer ();
327             if (!cert)
328               {
329                 log_error ("oops - failed to get cert again\n");
330                 rc = seterr (General_Error);
331                 goto leave;
332               }
333
334             sigval = NULL;
335             rc = gpgsm_create_cms_signature (cert, md, algo, &sigval);
336             if (rc)
337               {
338                 ksba_cert_release (cert);
339                 goto leave;
340               }
341
342             err = ksba_cms_set_sig_val (cms, signer, sigval);
343             xfree (sigval);
344             if (err)
345               {
346                 log_error ("failed to store the signature: %s\n",
347                            ksba_strerror (err));
348                 rc = map_ksba_err (err);
349                 goto leave;
350               }
351           }
352         }
353     }
354   while (stopreason != KSBA_SR_READY);   
355
356   log_info ("signature created\n");
357
358  leave:
359   ksba_cms_release (cms);
360   ksba_writer_release (writer);
361   keydb_release (kh); 
362   gcry_md_close (data_md);
363   if (rparm.fp)
364     fclose (rparm.fp);
365   return rc;
366 }