gpg: No need to create a trustdb when encrypting with --always-trust.
[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 allocate 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_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                   if (DBG_X509)
207                     log_debug ("enabling hash algorithm %d (%s)\n",
208                                algo, algoid? algoid:"");
209                   gcry_md_enable (data_md, algo);
210                   audit_log_i (ctrl->audit, AUDIT_DATA_HASH_ALGO, algo);
211                 }
212             }
213           if (opt.extra_digest_algo)
214             {
215               if (DBG_X509)
216                 log_debug ("enabling extra hash algorithm %d\n",
217                            opt.extra_digest_algo);
218               gcry_md_enable (data_md, opt.extra_digest_algo);
219               audit_log_i (ctrl->audit, AUDIT_DATA_HASH_ALGO,
220                            opt.extra_digest_algo);
221             }
222           if (is_detached)
223             {
224               if (data_fd == -1)
225                 {
226                   log_info ("detached signature w/o data "
227                             "- assuming certs-only\n");
228                   audit_log (ctrl->audit, AUDIT_CERT_ONLY_SIG);
229                 }
230               else
231                 audit_log_ok (ctrl->audit, AUDIT_DATA_HASHING,
232                               hash_data (data_fd, data_md));
233             }
234           else
235             {
236               ksba_cms_set_hash_function (cms, HASH_FNC, data_md);
237             }
238         }
239       else if (stopreason == KSBA_SR_END_DATA)
240         { /* The data bas been hashed */
241           audit_log_ok (ctrl->audit, AUDIT_DATA_HASHING, 0);
242         }
243     }
244   while (stopreason != KSBA_SR_READY);
245
246   if (b64writer)
247     {
248       rc = gpgsm_finish_writer (b64writer);
249       if (rc)
250         {
251           log_error ("write failed: %s\n", gpg_strerror (rc));
252           audit_log_ok (ctrl->audit, AUDIT_WRITE_ERROR, rc);
253           goto leave;
254         }
255     }
256
257   if (data_fd != -1 && !is_detached)
258     {
259       log_error ("data given for a non-detached signature\n");
260       rc = gpg_error (GPG_ERR_CONFLICT);
261       audit_log (ctrl->audit, AUDIT_USAGE_ERROR);
262       goto leave;
263     }
264
265   for (i=0; (cert=ksba_cms_get_cert (cms, i)); i++)
266     {
267       /* Fixme: it might be better to check the validity of the
268          certificate first before entering it into the DB.  This way
269          we would avoid cluttering the DB with invalid
270          certificates. */
271       audit_log_cert (ctrl->audit, AUDIT_SAVE_CERT, cert,
272                       keydb_store_cert (cert, 0, NULL));
273       ksba_cert_release (cert);
274     }
275
276   cert = NULL;
277   for (signer=0; ; signer++)
278     {
279       char *issuer = NULL;
280       ksba_sexp_t sigval = NULL;
281       ksba_isotime_t sigtime, keyexptime;
282       ksba_sexp_t serial;
283       char *msgdigest = NULL;
284       size_t msgdigestlen;
285       char *ctattr;
286       int sigval_hash_algo;
287       int info_pkalgo;
288       unsigned int verifyflags;
289
290       rc = ksba_cms_get_issuer_serial (cms, signer, &issuer, &serial);
291       if (!signer && gpg_err_code (rc) == GPG_ERR_NO_DATA
292           && data_fd == -1 && is_detached)
293         {
294           log_info ("certs-only message accepted\n");
295           rc = 0;
296           break;
297         }
298       if (rc)
299         {
300           if (signer && rc == -1)
301             rc = 0;
302           break;
303         }
304
305       gpgsm_status (ctrl, STATUS_NEWSIG, NULL);
306       audit_log_i (ctrl->audit, AUDIT_NEW_SIG, signer);
307
308       if (DBG_X509)
309         {
310           log_debug ("signer %d - issuer: `%s'\n",
311                      signer, issuer? issuer:"[NONE]");
312           log_debug ("signer %d - serial: ", signer);
313           gpgsm_dump_serial (serial);
314           log_printf ("\n");
315         }
316       if (ctrl->audit)
317         {
318           char *tmpstr = gpgsm_format_sn_issuer (serial, issuer);
319           audit_log_s (ctrl->audit, AUDIT_SIG_NAME, tmpstr);
320           xfree (tmpstr);
321         }
322
323       rc = ksba_cms_get_signing_time (cms, signer, sigtime);
324       if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
325         *sigtime = 0;
326       else if (rc)
327         {
328           log_error ("error getting signing time: %s\n", gpg_strerror (rc));
329           *sigtime = 0; /* (we can't encode an error in the time string.) */
330         }
331
332       rc = ksba_cms_get_message_digest (cms, signer,
333                                         &msgdigest, &msgdigestlen);
334       if (!rc)
335         {
336           size_t is_enabled;
337
338           algoid = ksba_cms_get_digest_algo (cms, signer);
339           algo = gcry_md_map_name (algoid);
340           if (DBG_X509)
341             log_debug ("signer %d - digest algo: %d\n", signer, algo);
342           is_enabled = sizeof algo;
343           if ( gcry_md_info (data_md, GCRYCTL_IS_ALGO_ENABLED,
344                              &algo, &is_enabled)
345                || !is_enabled)
346             {
347               log_error ("digest algo %d (%s) has not been enabled\n",
348                          algo, algoid?algoid:"");
349               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "unsupported");
350               goto next_signer;
351             }
352         }
353       else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
354         {
355           assert (!msgdigest);
356           rc = 0;
357           algoid = NULL;
358           algo = 0;
359         }
360       else /* real error */
361         {
362           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
363           break;
364         }
365
366       rc = ksba_cms_get_sigattr_oids (cms, signer,
367                                       "1.2.840.113549.1.9.3", &ctattr);
368       if (!rc)
369         {
370           const char *s;
371
372           if (DBG_X509)
373             log_debug ("signer %d - content-type attribute: %s",
374                        signer, ctattr);
375
376           s = ksba_cms_get_content_oid (cms, 1);
377           if (!s || strcmp (ctattr, s))
378             {
379               log_error ("content-type attribute does not match "
380                          "actual content-type\n");
381               ksba_free (ctattr);
382               ctattr = NULL;
383               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
384               goto next_signer;
385             }
386           ksba_free (ctattr);
387           ctattr = NULL;
388         }
389       else if (rc != -1)
390         {
391           log_error ("error getting content-type attribute: %s\n",
392                      gpg_strerror (rc));
393           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
394           goto next_signer;
395         }
396       rc = 0;
397
398
399       sigval = ksba_cms_get_sig_val (cms, signer);
400       if (!sigval)
401         {
402           log_error ("no signature value available\n");
403           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
404           goto next_signer;
405         }
406       sigval_hash_algo = hash_algo_from_sigval (sigval);
407       if (DBG_X509)
408         {
409           log_debug ("signer %d - signature available (sigval hash=%d)",
410                      signer, sigval_hash_algo);
411 /*           log_printhex ("sigval    ", sigval, */
412 /*                         gcry_sexp_canon_len (sigval, 0, NULL, NULL)); */
413         }
414       if (!sigval_hash_algo)
415         sigval_hash_algo = algo; /* Fallback used e.g. with old libksba. */
416
417       /* Find the certificate of the signer */
418       keydb_search_reset (kh);
419       rc = keydb_search_issuer_sn (kh, issuer, serial);
420       if (rc)
421         {
422           if (rc == -1)
423             {
424               log_error ("certificate not found\n");
425               rc = gpg_error (GPG_ERR_NO_PUBKEY);
426             }
427           else
428             log_error ("failed to find the certificate: %s\n",
429                        gpg_strerror(rc));
430           {
431             char numbuf[50];
432             sprintf (numbuf, "%d", rc);
433
434             gpgsm_status2 (ctrl, STATUS_ERROR, "verify.findkey",
435                            numbuf, NULL);
436           }
437           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "no-cert");
438           goto next_signer;
439         }
440
441       rc = keydb_get_cert (kh, &cert);
442       if (rc)
443         {
444           log_error ("failed to get cert: %s\n", gpg_strerror (rc));
445           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
446           goto next_signer;
447         }
448
449       log_info (_("Signature made "));
450       if (*sigtime)
451         dump_isotime (sigtime);
452       else
453         log_printf (_("[date not given]"));
454       log_printf (_(" using certificate ID 0x%08lX\n"),
455                   gpgsm_get_short_fingerprint (cert, NULL));
456
457       audit_log_i (ctrl->audit, AUDIT_DATA_HASH_ALGO, algo);
458
459       if (msgdigest)
460         { /* Signed attributes are available. */
461           gcry_md_hd_t md;
462           unsigned char *s;
463
464           /* Check that the message digest in the signed attributes
465              matches the one we calculated on the data.  */
466           s = gcry_md_read (data_md, algo);
467           if ( !s || !msgdigestlen
468                || gcry_md_get_algo_dlen (algo) != msgdigestlen
469                || !s || memcmp (s, msgdigest, msgdigestlen) )
470             {
471               char *fpr;
472
473               log_error (_("invalid signature: message digest attribute "
474                            "does not match computed one\n"));
475               if (DBG_X509)
476                 {
477                   if (msgdigest)
478                     log_printhex ("message:  ", msgdigest, msgdigestlen);
479                   if (s)
480                     log_printhex ("computed: ",
481                                   s, gcry_md_get_algo_dlen (algo));
482                 }
483               fpr = gpgsm_fpr_and_name_for_status (cert);
484               gpgsm_status (ctrl, STATUS_BADSIG, fpr);
485               xfree (fpr);
486               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
487               goto next_signer;
488             }
489
490           audit_log_i (ctrl->audit, AUDIT_ATTR_HASH_ALGO, sigval_hash_algo);
491           rc = gcry_md_open (&md, sigval_hash_algo, 0);
492           if (rc)
493             {
494               log_error ("md_open failed: %s\n", gpg_strerror (rc));
495               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
496               goto next_signer;
497             }
498           if (DBG_HASHING)
499             gcry_md_debug (md, "vrfy.attr");
500
501           ksba_cms_set_hash_function (cms, HASH_FNC, md);
502           rc = ksba_cms_hash_signed_attrs (cms, signer);
503           if (rc)
504             {
505               log_error ("hashing signed attrs failed: %s\n",
506                          gpg_strerror (rc));
507               gcry_md_close (md);
508               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
509               goto next_signer;
510             }
511           rc = gpgsm_check_cms_signature (cert, sigval, md,
512                                           sigval_hash_algo, &info_pkalgo);
513           gcry_md_close (md);
514         }
515       else
516         {
517           rc = gpgsm_check_cms_signature (cert, sigval, data_md,
518                                           algo, &info_pkalgo);
519         }
520
521       if (rc)
522         {
523           char *fpr;
524
525           log_error ("invalid signature: %s\n", gpg_strerror (rc));
526           fpr = gpgsm_fpr_and_name_for_status (cert);
527           gpgsm_status (ctrl, STATUS_BADSIG, fpr);
528           xfree (fpr);
529           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
530           goto next_signer;
531         }
532       rc = gpgsm_cert_use_verify_p (cert); /*(this displays an info message)*/
533       if (rc)
534         {
535           gpgsm_status_with_err_code (ctrl, STATUS_ERROR, "verify.keyusage",
536                                       gpg_err_code (rc));
537           rc = 0;
538         }
539
540       if (DBG_X509)
541         log_debug ("signature okay - checking certs\n");
542       audit_log (ctrl->audit, AUDIT_VALIDATE_CHAIN);
543       rc = gpgsm_validate_chain (ctrl, cert,
544                                  *sigtime? sigtime : "19700101T000000",
545                                  keyexptime, 0,
546                                  NULL, 0, &verifyflags);
547       {
548         char *fpr, *buf, *tstr;
549
550         fpr = gpgsm_fpr_and_name_for_status (cert);
551         if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED)
552           {
553             gpgsm_status (ctrl, STATUS_EXPKEYSIG, fpr);
554             rc = 0;
555           }
556         else
557           gpgsm_status (ctrl, STATUS_GOODSIG, fpr);
558
559         xfree (fpr);
560
561         fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
562         tstr = strtimestamp_r (sigtime);
563         buf = xasprintf ("%s %s %s %s 0 0 %d %d 00", fpr, tstr,
564                          *sigtime? sigtime : "0",
565                          *keyexptime? keyexptime : "0",
566                          info_pkalgo, algo);
567         xfree (tstr);
568         xfree (fpr);
569         gpgsm_status (ctrl, STATUS_VALIDSIG, buf);
570         xfree (buf);
571       }
572
573       audit_log_ok (ctrl->audit, AUDIT_CHAIN_STATUS, rc);
574       if (rc) /* of validate_chain */
575         {
576           log_error ("invalid certification chain: %s\n", gpg_strerror (rc));
577           if (gpg_err_code (rc) == GPG_ERR_BAD_CERT_CHAIN
578               || gpg_err_code (rc) == GPG_ERR_BAD_CERT
579               || gpg_err_code (rc) == GPG_ERR_BAD_CA_CERT
580               || gpg_err_code (rc) == GPG_ERR_CERT_REVOKED)
581             gpgsm_status_with_err_code (ctrl, STATUS_TRUST_NEVER, NULL,
582                                         gpg_err_code (rc));
583           else
584             gpgsm_status_with_err_code (ctrl, STATUS_TRUST_UNDEFINED, NULL,
585                                         gpg_err_code (rc));
586           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
587           goto next_signer;
588         }
589
590       audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "good");
591
592       for (i=0; (p = ksba_cert_get_subject (cert, i)); i++)
593         {
594           log_info (!i? _("Good signature from")
595                       : _("                aka"));
596           log_printf (" \"");
597           gpgsm_print_name (log_get_stream (), p);
598           log_printf ("\"\n");
599           ksba_free (p);
600         }
601
602       /* Print a note if this is a qualified signature.  */
603       {
604         size_t qualbuflen;
605         char qualbuffer[1];
606
607         rc = ksba_cert_get_user_data (cert, "is_qualified", &qualbuffer,
608                                       sizeof (qualbuffer), &qualbuflen);
609         if (!rc && qualbuflen)
610           {
611             if (*qualbuffer)
612               {
613                 log_info (_("This is a qualified signature\n"));
614                 if (!opt.qualsig_approval)
615                   log_info
616                     (_("Note, that this software is not officially approved "
617                        "to create or verify such signatures.\n"));
618               }
619           }
620         else if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
621           log_error ("get_user_data(is_qualified) failed: %s\n",
622                      gpg_strerror (rc));
623       }
624
625       gpgsm_status (ctrl, STATUS_TRUST_FULLY,
626                     (verifyflags & VALIDATE_FLAG_CHAIN_MODEL)?
627                     "0 chain": "0 shell");
628
629
630     next_signer:
631       rc = 0;
632       xfree (issuer);
633       xfree (serial);
634       xfree (sigval);
635       xfree (msgdigest);
636       ksba_cert_release (cert);
637       cert = NULL;
638     }
639   rc = 0;
640
641  leave:
642   ksba_cms_release (cms);
643   gpgsm_destroy_reader (b64reader);
644   gpgsm_destroy_writer (b64writer);
645   keydb_release (kh);
646   gcry_md_close (data_md);
647   if (fp)
648     fclose (fp);
649
650   if (rc)
651     {
652       char numbuf[50];
653       sprintf (numbuf, "%d", rc );
654       gpgsm_status2 (ctrl, STATUS_ERROR, "verify.leave",
655                      numbuf, NULL);
656     }
657
658   return rc;
659 }
660