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