2002-02-01 Marcus Brinkmann <marcus@g10code.de>
[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   KEYDB_SEARCH_DESC desc;
72   KsbaCert cert = NULL;
73   KEYDB_HANDLE kh = NULL;
74   int rc;
75
76   rc = keydb_classify_name (key, &desc);
77   if (rc)
78     {
79       log_error ("failed to find default signer: %s\n", gnupg_strerror (rc));
80       return NULL;
81     }
82
83   kh = keydb_new (0);
84   if (!kh)
85     return NULL;
86
87   rc = keydb_search (kh, &desc, 1);
88   if (rc)
89     {
90       log_debug ("failed to find default certificate: rc=%d\n", rc);
91     }
92   else 
93     {
94       rc = keydb_get_cert (kh, &cert);
95       if (rc)
96         {
97           log_debug ("failed to get cert: rc=%d\n", rc);
98         }
99     }
100
101   keydb_release (kh);
102   return cert;
103 }
104
105
106 /* Depending on the options in CTRL add the certifcate CERT as well as
107    other certificate up in the chain to the Root-CA to the CMS
108    object. */
109 static int 
110 add_certificate_list (CTRL ctrl, KsbaCMS cms, KsbaCert cert)
111 {
112   KsbaError err;
113   int rc = 0;
114   KsbaCert next = NULL;
115   int n;
116
117   ksba_cert_ref (cert);
118
119   n = ctrl->include_certs;
120   if (n < 0 || n > 50)
121     n = 50; /* We better apply an upper bound */
122
123   if (n)
124     {
125       err = ksba_cms_add_cert (cms, cert);
126       if (err)
127         goto ksba_failure;
128     }
129   while ( n-- && !(rc = gpgsm_walk_cert_chain (cert, &next)) )
130     {
131       err = ksba_cms_add_cert (cms, next);
132       ksba_cert_release (cert);
133       cert = next; next = NULL;
134       if (err)
135         goto ksba_failure;
136     }
137   ksba_cert_release (cert);
138
139   return rc == -1? 0: rc;
140
141  ksba_failure:
142   ksba_cert_release (cert);
143   log_error ("ksba_cms_add_cert failed: %s\n", ksba_strerror (err));
144   return map_ksba_err (err);
145 }
146
147
148
149 \f
150 /* Perform a sign operation.  
151
152    Sign the data received on DATA-FD in embedded mode or in deatched
153    mode when DETACHED is true.  Write the signature to OUT_FP The key
154    used to sign is the default - we will extend the fucntion to take a
155    list of fingerprints in the future. */
156 int
157 gpgsm_sign (CTRL ctrl, int data_fd, int detached, FILE *out_fp)
158 {
159   int i, rc;
160   KsbaError err;
161   Base64Context b64writer = NULL;
162   KsbaWriter writer;
163   KsbaCMS cms = NULL;
164   KsbaStopReason stopreason;
165   KsbaCert cert = NULL;
166   KEYDB_HANDLE kh = NULL;
167   GCRY_MD_HD data_md = NULL;
168   int signer;
169   const char *algoid;
170   int algo;
171   time_t signed_at;
172
173   if (!detached)
174     {
175        rc = seterr (Not_Implemented);
176        goto leave;
177     }
178
179
180   kh = keydb_new (0);
181   if (!kh)
182     {
183       log_error (_("failed to allocated keyDB handle\n"));
184       rc = GNUPG_General_Error;
185       goto leave;
186     }
187
188   ctrl->pem_name = "SIGNED MESSAGE";
189   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
190   if (rc)
191     {
192       log_error ("can't create writer: %s\n", gnupg_strerror (rc));
193       goto leave;
194     }
195
196   cms = ksba_cms_new ();
197   if (!cms)
198     {
199       rc = seterr (Out_Of_Core);
200       goto leave;
201     }
202
203   err = ksba_cms_set_reader_writer (cms, NULL, writer);
204   if (err)
205     {
206       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
207                  ksba_strerror (err));
208       rc = map_ksba_err (err);
209       goto leave;
210     }
211
212   /* We are going to create signed data with data as encap. content */
213   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_SIGNED_DATA);
214   if (!err)
215     err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
216   if (err)
217     {
218       log_debug ("ksba_cms_set_content_type failed: %s\n",
219                  ksba_strerror (err));
220       rc = map_ksba_err (err);
221       goto leave;
222     }
223
224
225   /* gather certificates of signers  and store in theCMS object */
226   /* fixme: process a list of fingerprints and store the certificate of
227      each given fingerprint */
228   cert = get_default_signer ();
229   if (!cert)
230     {
231       log_error ("no default signer found\n");
232       rc = seterr (General_Error);
233       goto leave;
234     }
235   err = ksba_cms_add_signer (cms, cert);
236   if (err)
237     {
238       log_error ("ksba_cms_add_signer failed: %s\n",  ksba_strerror (err));
239       rc = map_ksba_err (err);
240       goto leave;
241     }
242   rc = add_certificate_list (ctrl, cms, cert);
243   if (rc)
244     {
245       log_error ("failed to store list of certificates: %s\n",
246                  gnupg_strerror(rc));
247       goto leave;
248     }
249   ksba_cert_release (cert); cert = NULL;
250
251   
252   /* Set the hash algorithm we are going to use */
253   err = ksba_cms_add_digest_algo (cms, "1.3.14.3.2.26" /*SHA-1*/);
254   if (err)
255     {
256       log_debug ("ksba_cms_add_digest_algo failed: %s\n", ksba_strerror (err));
257       rc = map_ksba_err (err);
258       goto leave;
259     }
260
261   /* Prepare hashing (actually we are figuring out what we have set above)*/
262   data_md = gcry_md_open (0, 0);
263   if (!data_md)
264     {
265       rc = map_gcry_err (gcry_errno());
266       log_error ("md_open failed: %s\n", gcry_strerror (-1));
267       goto leave;
268     }
269   if (DBG_HASHING)
270     gcry_md_start_debug (data_md, "sign.data");
271
272   for (i=0; (algoid=ksba_cms_get_digest_algo_list (cms, i)); i++)
273     {
274       algo = gcry_md_map_name (algoid);
275       if (!algo)
276         {
277           log_error ("unknown hash algorithm `%s'\n", algoid? algoid:"?");
278           rc = GNUPG_Bug;
279           goto leave;
280         }
281       gcry_md_enable (data_md, algo);
282     }
283
284   signer = 0;
285   if (detached)
286     { /* we hash the data right now so that we can store the message
287          digest.  ksba_cms_build() takes this as an flag that detached
288          data is expected. */
289       unsigned char *digest;
290       size_t digest_len;
291       /* Fixme do this for all signers and get the algo to use from
292          the signer's certificate - does not make mich sense, bu we
293          should do this consistent as we have already done it above */
294       algo = GCRY_MD_SHA1; 
295       hash_data (data_fd, data_md);
296       digest = gcry_md_read (data_md, algo);
297       digest_len = gcry_md_get_algo_dlen (algo);
298       if ( !digest || !digest_len)
299         {
300           log_error ("problem getting the hash of the data\n");
301           rc = GNUPG_Bug;
302           goto leave;
303         }
304       err = ksba_cms_set_message_digest (cms, signer, digest, digest_len);
305       if (err)
306         {
307           log_error ("ksba_cms_set_message_digest failed: %s\n",
308                      ksba_strerror (err));
309           rc = map_ksba_err (err);
310           goto leave;
311         }
312     }
313
314   signed_at = time (NULL);
315   err = ksba_cms_set_signing_time (cms, signer, signed_at);
316   if (err)
317     {
318       log_error ("ksba_cms_set_signing_time failed: %s\n",
319                  ksba_strerror (err));
320       rc = map_ksba_err (err);
321       goto leave;
322     }
323
324   do 
325     {
326       err = ksba_cms_build (cms, &stopreason);
327       if (err)
328         {
329           log_debug ("ksba_cms_build failed: %s\n", ksba_strerror (err));
330           rc = map_ksba_err (err);
331           goto leave;
332         }
333
334       if (stopreason == KSBA_SR_BEGIN_DATA)
335         { /* hash the data and store the message digest */
336           assert (!detached);
337         }
338       else if (stopreason == KSBA_SR_NEED_SIG)
339         { /* calculate the signature for all signers */
340           GCRY_MD_HD md;
341
342           algo = GCRY_MD_SHA1;
343           signer = 0;
344           md = gcry_md_open (algo, 0);
345           if (DBG_HASHING)
346             gcry_md_start_debug (md, "sign.attr");
347
348           if (!md)
349             {
350               log_error ("md_open failed: %s\n", gcry_strerror (-1));
351               goto leave;
352             }
353           ksba_cms_set_hash_function (cms, HASH_FNC, md);
354           rc = ksba_cms_hash_signed_attrs (cms, signer);
355           if (rc)
356             {
357               log_debug ("hashing signed attrs failed: %s\n",
358                          ksba_strerror (rc));
359               gcry_md_close (md);
360               goto leave;
361             }
362           
363           { /* This is all an temporary hack */
364             char *sigval;
365             
366             ksba_cert_release (cert); 
367             cert = get_default_signer ();
368             if (!cert)
369               {
370                 log_error ("oops - failed to get cert again\n");
371                 rc = seterr (General_Error);
372                 goto leave;
373               }
374
375             sigval = NULL;
376             rc = gpgsm_create_cms_signature (cert, md, algo, &sigval);
377             if (rc)
378               goto leave;
379
380             err = ksba_cms_set_sig_val (cms, signer, sigval);
381             xfree (sigval);
382             if (err)
383               {
384                 log_error ("failed to store the signature: %s\n",
385                            ksba_strerror (err));
386                 rc = map_ksba_err (err);
387                 goto leave;
388               }
389
390             /* And write a status message */
391             {
392               char *buf, *fpr;
393               
394               fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
395               if (!fpr)
396                 {
397                   rc = seterr (Out_Of_Core);
398                   goto leave;
399                 }
400               rc = asprintf (&buf, "%c %d %d 00 %lu %s",
401                         detached? 'D':'S',
402                         GCRY_PK_RSA,  /* FIXME: get pk algo from cert */
403                         algo, 
404                         (ulong)signed_at,
405                         fpr);
406               xfree (fpr);
407               if (rc < 0)
408                 {
409                   rc = seterr (Out_Of_Core);
410                   goto leave;
411                 }
412               rc = 0;
413               gpgsm_status (ctrl, STATUS_SIG_CREATED, buf );
414               free (buf); /* yes, we must use the regular free() here */
415             }
416
417           }
418         }
419     }
420   while (stopreason != KSBA_SR_READY);   
421
422   rc = gpgsm_finish_writer (b64writer);
423   if (rc) 
424     {
425       log_error ("write failed: %s\n", gnupg_strerror (rc));
426       goto leave;
427     }
428
429   log_info ("signature created\n");
430
431
432  leave:
433   ksba_cert_release (cert); 
434   ksba_cms_release (cms);
435   gpgsm_destroy_writer (b64writer);
436   keydb_release (kh); 
437   gcry_md_close (data_md);
438   return rc;
439 }