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