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