common: Rename remaining symbols in ksba-io-support.
[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 "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           size_t is_enabled;
345
346           algoid = ksba_cms_get_digest_algo (cms, signer);
347           algo = gcry_md_map_name (algoid);
348           if (DBG_X509)
349             log_debug ("signer %d - digest algo: %d\n", signer, algo);
350           is_enabled = sizeof algo;
351           if ( gcry_md_info (data_md, GCRYCTL_IS_ALGO_ENABLED,
352                              &algo, &is_enabled)
353                || !is_enabled)
354             {
355               log_error ("digest algo %d (%s) has not been enabled\n",
356                          algo, algoid?algoid:"");
357               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "unsupported");
358               goto next_signer;
359             }
360         }
361       else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
362         {
363           assert (!msgdigest);
364           rc = 0;
365           algoid = NULL;
366           algo = 0;
367         }
368       else /* real error */
369         {
370           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
371           break;
372         }
373
374       rc = ksba_cms_get_sigattr_oids (cms, signer,
375                                       "1.2.840.113549.1.9.3", &ctattr);
376       if (!rc)
377         {
378           const char *s;
379
380           if (DBG_X509)
381             log_debug ("signer %d - content-type attribute: %s",
382                        signer, ctattr);
383
384           s = ksba_cms_get_content_oid (cms, 1);
385           if (!s || strcmp (ctattr, s))
386             {
387               log_error ("content-type attribute does not match "
388                          "actual content-type\n");
389               ksba_free (ctattr);
390               ctattr = NULL;
391               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
392               goto next_signer;
393             }
394           ksba_free (ctattr);
395           ctattr = NULL;
396         }
397       else if (rc != -1)
398         {
399           log_error ("error getting content-type attribute: %s\n",
400                      gpg_strerror (rc));
401           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
402           goto next_signer;
403         }
404       rc = 0;
405
406
407       sigval = ksba_cms_get_sig_val (cms, signer);
408       if (!sigval)
409         {
410           log_error ("no signature value available\n");
411           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
412           goto next_signer;
413         }
414       sigval_hash_algo = hash_algo_from_sigval (sigval);
415       if (DBG_X509)
416         {
417           log_debug ("signer %d - signature available (sigval hash=%d)",
418                      signer, sigval_hash_algo);
419 /*           log_printhex ("sigval    ", sigval, */
420 /*                         gcry_sexp_canon_len (sigval, 0, NULL, NULL)); */
421         }
422       if (!sigval_hash_algo)
423         sigval_hash_algo = algo; /* Fallback used e.g. with old libksba. */
424
425       /* Find the certificate of the signer */
426       keydb_search_reset (kh);
427       rc = keydb_search_issuer_sn (ctrl, kh, issuer, serial);
428       if (rc)
429         {
430           if (rc == -1)
431             {
432               log_error ("certificate not found\n");
433               rc = gpg_error (GPG_ERR_NO_PUBKEY);
434             }
435           else
436             log_error ("failed to find the certificate: %s\n",
437                        gpg_strerror(rc));
438           {
439             char numbuf[50];
440             sprintf (numbuf, "%d", rc);
441
442             gpgsm_status2 (ctrl, STATUS_ERROR, "verify.findkey",
443                            numbuf, NULL);
444           }
445           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "no-cert");
446           goto next_signer;
447         }
448
449       rc = keydb_get_cert (kh, &cert);
450       if (rc)
451         {
452           log_error ("failed to get cert: %s\n", gpg_strerror (rc));
453           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
454           goto next_signer;
455         }
456
457       log_info (_("Signature made "));
458       if (*sigtime)
459         dump_isotime (sigtime);
460       else
461         log_printf (_("[date not given]"));
462       log_printf (_(" using certificate ID 0x%08lX\n"),
463                   gpgsm_get_short_fingerprint (cert, NULL));
464
465       audit_log_i (ctrl->audit, AUDIT_DATA_HASH_ALGO, algo);
466
467       if (msgdigest)
468         { /* Signed attributes are available. */
469           gcry_md_hd_t md;
470           unsigned char *s;
471
472           /* Check that the message digest in the signed attributes
473              matches the one we calculated on the data.  */
474           s = gcry_md_read (data_md, algo);
475           if ( !s || !msgdigestlen
476                || gcry_md_get_algo_dlen (algo) != msgdigestlen
477                || memcmp (s, msgdigest, msgdigestlen) )
478             {
479               char *fpr;
480
481               log_error (_("invalid signature: message digest attribute "
482                            "does not match computed one\n"));
483               if (DBG_X509)
484                 {
485                   if (msgdigest)
486                     log_printhex ("message:  ", msgdigest, msgdigestlen);
487                   if (s)
488                     log_printhex ("computed: ",
489                                   s, gcry_md_get_algo_dlen (algo));
490                 }
491               fpr = gpgsm_fpr_and_name_for_status (cert);
492               gpgsm_status (ctrl, STATUS_BADSIG, fpr);
493               xfree (fpr);
494               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
495               goto next_signer;
496             }
497
498           audit_log_i (ctrl->audit, AUDIT_ATTR_HASH_ALGO, sigval_hash_algo);
499           rc = gcry_md_open (&md, sigval_hash_algo, 0);
500           if (rc)
501             {
502               log_error ("md_open failed: %s\n", gpg_strerror (rc));
503               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
504               goto next_signer;
505             }
506           if (DBG_HASHING)
507             gcry_md_debug (md, "vrfy.attr");
508
509           ksba_cms_set_hash_function (cms, HASH_FNC, md);
510           rc = ksba_cms_hash_signed_attrs (cms, signer);
511           if (rc)
512             {
513               log_error ("hashing signed attrs failed: %s\n",
514                          gpg_strerror (rc));
515               gcry_md_close (md);
516               audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "error");
517               goto next_signer;
518             }
519           rc = gpgsm_check_cms_signature (cert, sigval, md,
520                                           sigval_hash_algo, &info_pkalgo);
521           gcry_md_close (md);
522         }
523       else
524         {
525           rc = gpgsm_check_cms_signature (cert, sigval, data_md,
526                                           algo, &info_pkalgo);
527         }
528
529       if (rc)
530         {
531           char *fpr;
532
533           log_error ("invalid signature: %s\n", gpg_strerror (rc));
534           fpr = gpgsm_fpr_and_name_for_status (cert);
535           gpgsm_status (ctrl, STATUS_BADSIG, fpr);
536           xfree (fpr);
537           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
538           goto next_signer;
539         }
540       rc = gpgsm_cert_use_verify_p (cert); /*(this displays an info message)*/
541       if (rc)
542         {
543           gpgsm_status_with_err_code (ctrl, STATUS_ERROR, "verify.keyusage",
544                                       gpg_err_code (rc));
545           rc = 0;
546         }
547
548       if (DBG_X509)
549         log_debug ("signature okay - checking certs\n");
550       audit_log (ctrl->audit, AUDIT_VALIDATE_CHAIN);
551       rc = gpgsm_validate_chain (ctrl, cert,
552                                  *sigtime? sigtime : "19700101T000000",
553                                  keyexptime, 0,
554                                  NULL, 0, &verifyflags);
555       {
556         char *fpr, *buf, *tstr;
557
558         fpr = gpgsm_fpr_and_name_for_status (cert);
559         if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED)
560           {
561             gpgsm_status (ctrl, STATUS_EXPKEYSIG, fpr);
562             rc = 0;
563           }
564         else
565           gpgsm_status (ctrl, STATUS_GOODSIG, fpr);
566
567         xfree (fpr);
568
569         fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
570         tstr = strtimestamp_r (sigtime);
571         buf = xasprintf ("%s %s %s %s 0 0 %d %d 00", fpr, tstr,
572                          *sigtime? sigtime : "0",
573                          *keyexptime? keyexptime : "0",
574                          info_pkalgo, algo);
575         xfree (tstr);
576         xfree (fpr);
577         gpgsm_status (ctrl, STATUS_VALIDSIG, buf);
578         xfree (buf);
579       }
580
581       audit_log_ok (ctrl->audit, AUDIT_CHAIN_STATUS, rc);
582       if (rc) /* of validate_chain */
583         {
584           log_error ("invalid certification chain: %s\n", gpg_strerror (rc));
585           if (gpg_err_code (rc) == GPG_ERR_BAD_CERT_CHAIN
586               || gpg_err_code (rc) == GPG_ERR_BAD_CERT
587               || gpg_err_code (rc) == GPG_ERR_BAD_CA_CERT
588               || gpg_err_code (rc) == GPG_ERR_CERT_REVOKED)
589             gpgsm_status_with_err_code (ctrl, STATUS_TRUST_NEVER, NULL,
590                                         gpg_err_code (rc));
591           else
592             gpgsm_status_with_err_code (ctrl, STATUS_TRUST_UNDEFINED, NULL,
593                                         gpg_err_code (rc));
594           audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "bad");
595           goto next_signer;
596         }
597
598       audit_log_s (ctrl->audit, AUDIT_SIG_STATUS, "good");
599
600       for (i=0; (p = ksba_cert_get_subject (cert, i)); i++)
601         {
602           log_info (!i? _("Good signature from")
603                       : _("                aka"));
604           log_printf (" \"");
605           gpgsm_es_print_name (log_get_stream (), p);
606           log_printf ("\"\n");
607           ksba_free (p);
608         }
609
610       /* Print a note if this is a qualified signature.  */
611       {
612         size_t qualbuflen;
613         char qualbuffer[1];
614
615         rc = ksba_cert_get_user_data (cert, "is_qualified", &qualbuffer,
616                                       sizeof (qualbuffer), &qualbuflen);
617         if (!rc && qualbuflen)
618           {
619             if (*qualbuffer)
620               {
621                 log_info (_("This is a qualified signature\n"));
622                 if (!opt.qualsig_approval)
623                   log_info
624                     (_("Note, that this software is not officially approved "
625                        "to create or verify such signatures.\n"));
626               }
627           }
628         else if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
629           log_error ("get_user_data(is_qualified) failed: %s\n",
630                      gpg_strerror (rc));
631       }
632
633       gpgsm_status (ctrl, STATUS_TRUST_FULLY,
634                     (verifyflags & VALIDATE_FLAG_STEED)?
635                     "0 steed":
636                     (verifyflags & VALIDATE_FLAG_CHAIN_MODEL)?
637                     "0 chain": "0 shell");
638
639
640     next_signer:
641       rc = 0;
642       xfree (issuer);
643       xfree (serial);
644       xfree (sigval);
645       xfree (msgdigest);
646       ksba_cert_release (cert);
647       cert = NULL;
648     }
649   rc = 0;
650
651  leave:
652   ksba_cms_release (cms);
653   gnupg_ksba_destroy_reader (b64reader);
654   gnupg_ksba_destroy_writer (b64writer);
655   keydb_release (kh);
656   gcry_md_close (data_md);
657   es_fclose (in_fp);
658
659   if (rc)
660     {
661       char numbuf[50];
662       sprintf (numbuf, "%d", rc );
663       gpgsm_status2 (ctrl, STATUS_ERROR, "verify.leave",
664                      numbuf, NULL);
665     }
666
667   return rc;
668 }