More code for the audit log.
[gnupg.git] / sm / verify.c
1 /* verify.c - Verify a messages signature
2  * Copyright (C) 2001, 2002, 2003, 2007 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <unistd.h> 
26 #include <time.h>
27 #include <assert.h>
28
29 #include "gpgsm.h"
30 #include <gcrypt.h>
31 #include <ksba.h>
32
33 #include "keydb.h"
34 #include "i18n.h"
35
36 static char *
37 strtimestamp_r (ksba_isotime_t atime)
38 {
39   char *buffer = xmalloc (15);
40   
41   if (!atime || !*atime)
42     strcpy (buffer, "none");
43   else
44     sprintf (buffer, "%.4s-%.2s-%.2s", atime, atime+4, atime+6);
45   return buffer;
46 }
47
48
49
50 /* Hash the data for a detached signature.  Returns 0 on success.  */
51 static gpg_error_t
52 hash_data (int fd, gcry_md_hd_t md)
53 {
54   gpg_error_t err = 0;
55   FILE *fp;
56   char buffer[4096];
57   int nread;
58
59   fp = fdopen ( dup (fd), "rb");
60   if (!fp)
61     {
62       err = gpg_error_from_syserror ();
63       log_error ("fdopen(%d) failed: %s\n", fd, gpg_strerror (err));
64       return err;
65     }
66
67   do 
68     {
69       nread = fread (buffer, 1, DIM(buffer), fp);
70       gcry_md_write (md, buffer, nread);
71     }
72   while (nread);
73   if (ferror (fp))
74     {
75       err = gpg_error_from_syserror ();
76       log_error ("read error on fd %d: %s\n", fd, gpg_strerror (err));
77     }
78   fclose (fp);
79   return err;
80 }
81
82
83
84 \f
85 /* Perform a verify operation.  To verify detached signatures, data_fd
86    must be different than -1.  With OUT_FP given and a non-detached
87    signature, the signed material is written to that stream. */
88 int
89 gpgsm_verify (ctrl_t ctrl, int in_fd, int data_fd, FILE *out_fp)
90 {
91   int i, rc;
92   Base64Context b64reader = NULL;
93   Base64Context b64writer = NULL;
94   ksba_reader_t reader;
95   ksba_writer_t writer = NULL;
96   ksba_cms_t cms = NULL;
97   ksba_stop_reason_t stopreason;
98   ksba_cert_t cert;
99   KEYDB_HANDLE kh;
100   gcry_md_hd_t data_md = NULL;
101   int signer;
102   const char *algoid;
103   int algo;
104   int is_detached;
105   FILE *fp = NULL;
106   char *p;
107
108   audit_set_type (ctrl->audit, AUDIT_TYPE_VERIFY);
109
110   kh = keydb_new (0);
111   if (!kh)
112     {
113       log_error (_("failed to allocated keyDB handle\n"));
114       rc = gpg_error (GPG_ERR_GENERAL);
115       goto leave;
116     }
117
118
119   fp = fdopen ( dup (in_fd), "rb");
120   if (!fp)
121     {
122       rc = gpg_error (gpg_err_code_from_errno (errno));
123       log_error ("fdopen() failed: %s\n", strerror (errno));
124       goto leave;
125     }
126
127   rc = gpgsm_create_reader (&b64reader, ctrl, fp, 0, &reader);
128   if (rc)
129     {
130       log_error ("can't create reader: %s\n", gpg_strerror (rc));
131       goto leave;
132     }
133
134   if (out_fp)
135     {
136       rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, NULL, &writer);
137       if (rc)
138         {
139           log_error ("can't create writer: %s\n", gpg_strerror (rc));
140           goto leave;
141         }
142     }
143
144   rc = ksba_cms_new (&cms);
145   if (rc)
146     goto leave;
147
148   rc = ksba_cms_set_reader_writer (cms, reader, writer);
149   if (rc)
150     {
151       log_error ("ksba_cms_set_reader_writer failed: %s\n",
152                  gpg_strerror (rc));
153       goto leave;
154     }
155
156   rc = gcry_md_open (&data_md, 0, 0);
157   if (rc)
158     {
159       log_error ("md_open failed: %s\n", gpg_strerror (rc));
160       goto leave;
161     }
162   if (DBG_HASHING)
163     gcry_md_start_debug (data_md, "vrfy.data");
164
165   audit_log (ctrl->audit, AUDIT_SETUP_READY);
166
167   is_detached = 0;
168   do 
169     {
170       rc = ksba_cms_parse (cms, &stopreason);
171       if (rc)
172         {
173           log_error ("ksba_cms_parse failed: %s\n", gpg_strerror (rc));
174           goto leave;
175         }
176
177       if (stopreason == KSBA_SR_NEED_HASH)
178         {
179           is_detached = 1;
180           audit_log (ctrl->audit, AUDIT_DETACHED_SIGNATURE);
181           if (opt.verbose)
182             log_info ("detached signature\n");
183         }
184
185       if (stopreason == KSBA_SR_NEED_HASH
186           || stopreason == KSBA_SR_BEGIN_DATA)
187         { 
188           audit_log (ctrl->audit, AUDIT_GOT_DATA);
189
190           /* We are now able to enable the hash algorithms */
191           for (i=0; (algoid=ksba_cms_get_digest_algo_list (cms, i)); i++)
192             {
193               algo = gcry_md_map_name (algoid);
194               if (!algo)
195                 {
196                   log_error ("unknown hash algorithm `%s'\n",
197                              algoid? algoid:"?");
198                   if (algoid
199                       && (  !strcmp (algoid, "1.2.840.113549.1.1.2")
200                           ||!strcmp (algoid, "1.2.840.113549.2.2")))
201                     log_info (_("(this is the MD2 algorithm)\n"));
202                   audit_log_s (ctrl->audit, AUDIT_BAD_DATA_HASH_ALGO, algoid);
203                 }
204               else
205                 {
206                   gcry_md_enable (data_md, algo);
207                   audit_log_i (ctrl->audit, AUDIT_DATA_HASH_ALGO, algo);
208                 }
209             }
210           if (is_detached)
211             {
212               if (data_fd == -1)
213                 {
214                   log_info ("detached signature w/o data "
215                             "- assuming certs-only\n");
216                   audit_log (ctrl->audit, AUDIT_CERT_ONLY_SIG);
217                 }
218               else
219                 audit_log_ok (ctrl->audit, AUDIT_DATA_HASHING,
220                               hash_data (data_fd, data_md));
221             }
222           else
223             {
224               ksba_cms_set_hash_function (cms, HASH_FNC, data_md);
225             }
226         }
227       else if (stopreason == KSBA_SR_END_DATA)
228         { /* The data bas been hashed */
229
230         }
231     }
232   while (stopreason != KSBA_SR_READY);   
233
234   if (b64writer)
235     {
236       rc = gpgsm_finish_writer (b64writer);
237       if (rc) 
238         {
239           log_error ("write failed: %s\n", gpg_strerror (rc));
240           audit_log_ok (ctrl->audit, AUDIT_WRITE_ERROR, rc);
241           goto leave;
242         }
243     }
244
245   if (data_fd != -1 && !is_detached)
246     {
247       log_error ("data given for a non-detached signature\n");
248       rc = gpg_error (GPG_ERR_CONFLICT);
249       audit_log (ctrl->audit, AUDIT_USAGE_ERROR);
250       goto leave;
251     }
252
253   for (i=0; (cert=ksba_cms_get_cert (cms, i)); i++)
254     {
255       /* Fixme: it might be better to check the validity of the
256          certificate first before entering it into the DB.  This way
257          we would avoid cluttering the DB with invalid
258          certificates. */
259       audit_log_cert (ctrl->audit, AUDIT_SAVE_CERT, cert, 
260                       keydb_store_cert (cert, 0, NULL));
261       ksba_cert_release (cert);
262     }
263
264   cert = NULL;
265   for (signer=0; ; signer++)
266     {
267       char *issuer = NULL;
268       ksba_sexp_t sigval = NULL;
269       ksba_isotime_t sigtime, keyexptime;
270       ksba_sexp_t serial;
271       char *msgdigest = NULL;
272       size_t msgdigestlen;
273       char *ctattr;
274       int info_pkalgo;
275       unsigned int verifyflags;
276
277       rc = ksba_cms_get_issuer_serial (cms, signer, &issuer, &serial);
278       if (!signer && gpg_err_code (rc) == GPG_ERR_NO_DATA
279           && data_fd == -1 && is_detached)
280         {
281           log_info ("certs-only message accepted\n");
282           rc = 0;
283           break;
284         }
285       if (rc)
286         {
287           if (signer && rc == -1)
288             rc = 0;
289           break;
290         }
291
292       gpgsm_status (ctrl, STATUS_NEWSIG, NULL);
293       audit_log_i (ctrl->audit, AUDIT_NEW_SIG, signer);
294
295       if (DBG_X509)
296         {
297           log_debug ("signer %d - issuer: `%s'\n",
298                      signer, issuer? issuer:"[NONE]");
299           log_debug ("signer %d - serial: ", signer);
300           gpgsm_dump_serial (serial);
301           log_printf ("\n");
302         }
303       if (ctrl->audit)
304         {
305           char *tmpstr = gpgsm_format_sn_issuer (serial, issuer);
306           audit_log_s (ctrl->audit, AUDIT_SIG_NAME, tmpstr);
307           xfree (tmpstr);
308         }
309
310       rc = ksba_cms_get_signing_time (cms, signer, sigtime);
311       if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
312         *sigtime = 0;
313       else if (rc)
314         {
315           log_error ("error getting signing time: %s\n", gpg_strerror (rc));
316           *sigtime = 0; /* (we can't encode an error in the time string.) */
317         }
318
319       rc = ksba_cms_get_message_digest (cms, signer,
320                                         &msgdigest, &msgdigestlen);
321       if (!rc)
322         {
323           size_t is_enabled;
324
325           algoid = ksba_cms_get_digest_algo (cms, signer);
326           algo = gcry_md_map_name (algoid);
327           if (DBG_X509)
328             log_debug ("signer %d - digest algo: %d\n", signer, algo);
329           is_enabled = sizeof algo;
330           if ( gcry_md_info (data_md, GCRYCTL_IS_ALGO_ENABLED,
331                              &algo, &is_enabled)
332                || !is_enabled)
333             {
334               log_error ("digest algo %d has not been enabled\n", algo);
335               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "unsupported");
336               goto next_signer;
337             }
338         }
339       else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
340         {
341           assert (!msgdigest);
342           rc = 0;
343           algoid = NULL;
344           algo = 0; 
345         }
346       else /* real error */
347         {
348           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
349           break;
350         }
351
352       rc = ksba_cms_get_sigattr_oids (cms, signer,
353                                       "1.2.840.113549.1.9.3", &ctattr);
354       if (!rc) 
355         {
356           const char *s;
357
358           if (DBG_X509)
359             log_debug ("signer %d - content-type attribute: %s",
360                        signer, ctattr);
361
362           s = ksba_cms_get_content_oid (cms, 1);
363           if (!s || strcmp (ctattr, s))
364             {
365               log_error ("content-type attribute does not match "
366                          "actual content-type\n");
367               ksba_free (ctattr);
368               ctattr = NULL;
369               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
370               goto next_signer;
371             }
372           ksba_free (ctattr);
373           ctattr = NULL;
374         }
375       else if (rc != -1)
376         {
377           log_error ("error getting content-type attribute: %s\n",
378                      gpg_strerror (rc));
379           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
380           goto next_signer;
381         }
382       rc = 0;
383
384
385       sigval = ksba_cms_get_sig_val (cms, signer);
386       if (!sigval)
387         {
388           log_error ("no signature value available\n");
389           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
390           goto next_signer;
391         }
392       if (DBG_X509)
393         log_debug ("signer %d - signature available", signer);
394
395       /* Find the certificate of the signer */
396       keydb_search_reset (kh);
397       rc = keydb_search_issuer_sn (kh, issuer, serial);
398       if (rc)
399         {
400           if (rc == -1)
401             {
402               log_error ("certificate not found\n");
403               rc = gpg_error (GPG_ERR_NO_PUBKEY);
404             }
405           else
406             log_error ("failed to find the certificate: %s\n",
407                        gpg_strerror(rc));
408           {
409             char numbuf[50];
410             sprintf (numbuf, "%d", rc);
411
412             gpgsm_status2 (ctrl, STATUS_ERROR, "verify.findkey",
413                            numbuf, NULL);
414           }
415           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "no-cert");
416           goto next_signer;
417         }
418
419       rc = keydb_get_cert (kh, &cert);
420       if (rc)
421         {
422           log_error ("failed to get cert: %s\n", gpg_strerror (rc));
423           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
424           goto next_signer;
425         }
426
427       log_info (_("Signature made "));
428       if (*sigtime)
429         gpgsm_dump_time (sigtime);
430       else
431         log_printf (_("[date not given]"));
432       log_printf (_(" using certificate ID 0x%08lX\n"),
433                   gpgsm_get_short_fingerprint (cert));
434
435
436       if (msgdigest)
437         { /* Signed attributes are available. */
438           gcry_md_hd_t md;
439           unsigned char *s;
440
441           /* check that the message digest in the signed attributes
442              matches the one we calculated on the data */
443           s = gcry_md_read (data_md, algo);
444           if ( !s || !msgdigestlen
445                || gcry_md_get_algo_dlen (algo) != msgdigestlen
446                || !s || memcmp (s, msgdigest, msgdigestlen) )
447             {
448               char *fpr;
449
450               log_error ("invalid signature: message digest attribute "
451                          "does not match calculated one\n");
452               fpr = gpgsm_fpr_and_name_for_status (cert);
453               gpgsm_status (ctrl, STATUS_BADSIG, fpr);
454               xfree (fpr);
455               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
456               goto next_signer; 
457             }
458             
459           rc = gcry_md_open (&md, algo, 0);
460           if (rc)
461             {
462               log_error ("md_open failed: %s\n", gpg_strerror (rc));
463               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
464               goto next_signer;
465             }
466           if (DBG_HASHING)
467             gcry_md_start_debug (md, "vrfy.attr");
468
469           ksba_cms_set_hash_function (cms, HASH_FNC, md);
470           rc = ksba_cms_hash_signed_attrs (cms, signer);
471           if (rc)
472             {
473               log_error ("hashing signed attrs failed: %s\n",
474                          gpg_strerror (rc));
475               gcry_md_close (md);
476               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
477               goto next_signer;
478             }
479           rc = gpgsm_check_cms_signature (cert, sigval, md, algo, 
480                                           &info_pkalgo);
481           gcry_md_close (md);
482         }
483       else
484         {
485           rc = gpgsm_check_cms_signature (cert, sigval, data_md, algo, 
486                                           &info_pkalgo);
487         }
488
489       if (rc)
490         {
491           char *fpr;
492
493           log_error ("invalid signature: %s\n", gpg_strerror (rc));
494           fpr = gpgsm_fpr_and_name_for_status (cert);
495           gpgsm_status (ctrl, STATUS_BADSIG, fpr);
496           xfree (fpr);
497           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
498           goto next_signer;
499         }
500       rc = gpgsm_cert_use_verify_p (cert); /*(this displays an info message)*/
501       if (rc)
502         {
503           gpgsm_status_with_err_code (ctrl, STATUS_ERROR, "verify.keyusage",
504                                       gpg_err_code (rc));
505           rc = 0;
506         }
507
508       if (DBG_X509)
509         log_debug ("signature okay - checking certs\n");
510       audit_log (ctrl->audit, AUDIT_VALIDATE_CHAIN);
511       rc = gpgsm_validate_chain (ctrl, cert,
512                                  *sigtime? sigtime : "19700101T000000",
513                                  keyexptime, 0, 
514                                  NULL, 0, &verifyflags);
515       {
516         char *fpr, *buf, *tstr;
517
518         fpr = gpgsm_fpr_and_name_for_status (cert);
519         if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED)
520           {
521             gpgsm_status (ctrl, STATUS_EXPKEYSIG, fpr);
522             rc = 0;
523           }
524         else
525           gpgsm_status (ctrl, STATUS_GOODSIG, fpr);
526         
527         xfree (fpr);
528
529         fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
530         tstr = strtimestamp_r (sigtime);
531         buf = xasprintf ("%s %s %s %s 0 0 %d %d 00", fpr, tstr,
532                          *sigtime? sigtime : "0",
533                          *keyexptime? keyexptime : "0",
534                          info_pkalgo, algo);
535         xfree (tstr);
536         xfree (fpr);
537         gpgsm_status (ctrl, STATUS_VALIDSIG, buf);
538         xfree (buf);
539       }
540
541       audit_log_ok (ctrl->audit, AUDIT_CHAIN_STATUS, rc);
542       if (rc) /* of validate_chain */
543         {
544           log_error ("invalid certification chain: %s\n", gpg_strerror (rc));
545           if (gpg_err_code (rc) == GPG_ERR_BAD_CERT_CHAIN
546               || gpg_err_code (rc) == GPG_ERR_BAD_CERT
547               || gpg_err_code (rc) == GPG_ERR_BAD_CA_CERT
548               || gpg_err_code (rc) == GPG_ERR_CERT_REVOKED)
549             gpgsm_status_with_err_code (ctrl, STATUS_TRUST_NEVER, NULL,
550                                         gpg_err_code (rc));
551           else
552             gpgsm_status_with_err_code (ctrl, STATUS_TRUST_UNDEFINED, NULL, 
553                                         gpg_err_code (rc));
554           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
555           goto next_signer;
556         }
557
558       audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "good");
559
560       for (i=0; (p = ksba_cert_get_subject (cert, i)); i++)
561         {
562           log_info (!i? _("Good signature from")
563                       : _("                aka"));
564           log_printf (" \"");
565           gpgsm_print_name (log_get_stream (), p);
566           log_printf ("\"\n");
567           ksba_free (p);
568         }
569
570       /* Print a note if this is a qualified signature.  */
571       {
572         size_t qualbuflen;
573         char qualbuffer[1];
574         
575         rc = ksba_cert_get_user_data (cert, "is_qualified", &qualbuffer,
576                                       sizeof (qualbuffer), &qualbuflen);
577         if (!rc && qualbuflen)
578           {
579             if (*qualbuffer)
580               {
581                 log_info (_("This is a qualified signature\n"));
582                 if (!opt.qualsig_approval)
583                   log_info 
584                     (_("Note, that this software is not officially approved "
585                        "to create or verify such signatures.\n"));
586               }
587           }    
588         else if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
589           log_error ("get_user_data(is_qualified) failed: %s\n",
590                      gpg_strerror (rc)); 
591       }
592
593       gpgsm_status (ctrl, STATUS_TRUST_FULLY, 
594                     (verifyflags & VALIDATE_FLAG_CHAIN_MODEL)?
595                     "0 chain": "0 shell");
596           
597
598     next_signer:
599       rc = 0;
600       xfree (issuer);
601       xfree (serial);
602       xfree (sigval);
603       xfree (msgdigest);
604       ksba_cert_release (cert);
605       cert = NULL;
606     }
607   rc = 0;
608
609  leave:
610   ksba_cms_release (cms);
611   gpgsm_destroy_reader (b64reader);
612   gpgsm_destroy_writer (b64writer);
613   keydb_release (kh); 
614   gcry_md_close (data_md);
615   if (fp)
616     fclose (fp);
617
618   if (rc)
619     {
620       char numbuf[50];
621       sprintf (numbuf, "%d", rc );
622       gpgsm_status2 (ctrl, STATUS_ERROR, "verify.leave",
623                      numbuf, NULL);
624     }
625
626   return rc;
627 }
628