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