gpg: Do not bail on an invalid packet in the local keyring.
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle packets
2  * Copyright (C) 1998-2009 Free Software Foundation, Inc.
3  * Copyright (C) 2013-2014 Werner Koch
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 <time.h>
26
27 #include "gpg.h"
28 #include "../common/util.h"
29 #include "packet.h"
30 #include "../common/iobuf.h"
31 #include "options.h"
32 #include "keydb.h"
33 #include "filter.h"
34 #include "main.h"
35 #include "../common/status.h"
36 #include "../common/i18n.h"
37 #include "trustdb.h"
38 #include "keyserver-internal.h"
39 #include "photoid.h"
40 #include "../common/mbox-util.h"
41 #include "call-dirmngr.h"
42 #include "../common/compliance.h"
43
44 /* Put an upper limit on nested packets.  The 32 is an arbitrary
45    value, a much lower should actually be sufficient.  */
46 #define MAX_NESTING_DEPTH 32
47
48
49 /*
50  * Object to hold the processing context.
51  */
52 typedef struct mainproc_context *CTX;
53 struct mainproc_context
54 {
55   ctrl_t ctrl;
56   struct mainproc_context *anchor;  /* May be useful in the future. */
57   PKT_public_key *last_pubkey;
58   PKT_user_id     *last_user_id;
59   md_filter_context_t mfx;
60   int sigs_only;    /* Process only signatures and reject all other stuff. */
61   int encrypt_only; /* Process only encryption messages. */
62
63   /* Name of the file with the complete signature or the file with the
64      detached signature.  This is currently only used to deduce the
65      file name of the data file if that has not been given. */
66   const char *sigfilename;
67
68   /* A structure to describe the signed data in case of a detached
69      signature. */
70   struct
71   {
72     /* A file descriptor of the signed data.  Only used if not -1. */
73     int data_fd;
74     /* A list of filenames with the data files or NULL. This is only
75        used if DATA_FD is -1. */
76     strlist_t data_names;
77     /* Flag to indicated that either one of the next previous fields
78        is used.  This is only needed for better readability. */
79     int used;
80   } signed_data;
81
82   DEK *dek;
83   int last_was_session_key;
84   kbnode_t list;    /* The current list of packets. */
85   iobuf_t iobuf;    /* Used to get the filename etc. */
86   int trustletter;  /* Temporary usage in list_node. */
87   ulong symkeys;    /* Number of symmetrically encrypted session keys.  */
88   struct pubkey_enc_list *pkenc_list; /* List of encryption packets. */
89   int seen_pkt_encrypted_aead; /* PKT_ENCRYPTED_AEAD packet seen. */
90   struct {
91     unsigned int sig_seen:1;      /* Set to true if a signature packet
92                                      has been seen. */
93     unsigned int data:1;          /* Any data packet seen */
94     unsigned int uncompress_failed:1;
95   } any;
96 };
97
98
99 /* Counter with the number of literal data packets seen.  Note that
100  * this is also bumped at the end of an encryption.  This counter is
101  * used for a basic consistency check of a received PGP message.  */
102 static int literals_seen;
103
104
105 /*** Local prototypes.  ***/
106 static int do_proc_packets (CTX c, iobuf_t a);
107 static void list_node (CTX c, kbnode_t node);
108 static void proc_tree (CTX c, kbnode_t node);
109
110
111 /*** Functions.  ***/
112
113 /* Reset the literal data counter.  This is required to setup a new
114  * decryption or verification context.  */
115 void
116 reset_literals_seen(void)
117 {
118   literals_seen = 0;
119 }
120
121
122 static void
123 release_list( CTX c )
124 {
125   proc_tree (c, c->list);
126   release_kbnode (c->list);
127   while (c->pkenc_list)
128     {
129       struct pubkey_enc_list *tmp = c->pkenc_list->next;
130
131       mpi_release (c->pkenc_list->data[0]);
132       mpi_release (c->pkenc_list->data[1]);
133       xfree (c->pkenc_list);
134       c->pkenc_list = tmp;
135     }
136   c->pkenc_list = NULL;
137   c->list = NULL;
138   c->any.data = 0;
139   c->any.uncompress_failed = 0;
140   c->last_was_session_key = 0;
141   c->seen_pkt_encrypted_aead = 0;
142   xfree (c->dek);
143   c->dek = NULL;
144 }
145
146
147 static int
148 add_onepass_sig (CTX c, PACKET *pkt)
149 {
150   kbnode_t node;
151
152   if (c->list) /* Add another packet. */
153     add_kbnode (c->list, new_kbnode (pkt));
154   else /* Insert the first one.  */
155     c->list = node = new_kbnode (pkt);
156
157   return 1;
158 }
159
160
161 static int
162 add_gpg_control (CTX c, PACKET *pkt)
163 {
164   if ( pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
165     {
166       /* New clear text signature.
167        * Process the last one and reset everything */
168       release_list(c);
169     }
170
171   if (c->list)  /* Add another packet.  */
172     add_kbnode (c->list, new_kbnode (pkt));
173   else /* Insert the first one. */
174     c->list = new_kbnode (pkt);
175
176   return 1;
177 }
178
179
180 static int
181 add_user_id (CTX c, PACKET *pkt)
182 {
183   if (!c->list)
184     {
185       log_error ("orphaned user ID\n");
186       return 0;
187     }
188   add_kbnode (c->list, new_kbnode (pkt));
189   return 1;
190 }
191
192
193 static int
194 add_subkey (CTX c, PACKET *pkt)
195 {
196   if (!c->list)
197     {
198       log_error ("subkey w/o mainkey\n");
199       return 0;
200     }
201   add_kbnode (c->list, new_kbnode (pkt));
202   return 1;
203 }
204
205
206 static int
207 add_ring_trust (CTX c, PACKET *pkt)
208 {
209   if (!c->list)
210     {
211       log_error ("ring trust w/o key\n");
212       return 0;
213     }
214   add_kbnode (c->list, new_kbnode (pkt));
215   return 1;
216 }
217
218
219 static int
220 add_signature (CTX c, PACKET *pkt)
221 {
222   kbnode_t node;
223
224   c->any.sig_seen = 1;
225   if (pkt->pkttype == PKT_SIGNATURE && !c->list)
226     {
227       /* This is the first signature for the following datafile.
228        * GPG does not write such packets; instead it always uses
229        * onepass-sig packets.  The drawback of PGP's method
230        * of prepending the signature to the data is
231        * that it is not possible to make a signature from data read
232        * from stdin.    (GPG is able to read PGP stuff anyway.) */
233       node = new_kbnode (pkt);
234       c->list = node;
235       return 1;
236     }
237   else if (!c->list)
238     return 0; /* oops (invalid packet sequence)*/
239   else if (!c->list->pkt)
240     BUG();    /* so nicht */
241
242   /* Add a new signature node item at the end. */
243   node = new_kbnode (pkt);
244   add_kbnode (c->list, node);
245
246   return 1;
247 }
248
249 static gpg_error_t
250 symkey_decrypt_seskey (DEK *dek, byte *seskey, size_t slen)
251 {
252   gpg_error_t err;
253   gcry_cipher_hd_t hd;
254   unsigned int noncelen, keylen;
255   enum gcry_cipher_modes ciphermode;
256
257   if (dek->use_aead)
258     {
259       err = openpgp_aead_algo_info (dek->use_aead, &ciphermode, &noncelen);
260       if (err)
261         return err;
262     }
263   else
264     {
265       ciphermode = GCRY_CIPHER_MODE_CFB;
266       noncelen = 0;
267     }
268
269   /* Check that the session key has a size of 16 to 32 bytes.  */
270   if ((dek->use_aead && (slen < (noncelen + 16 + 16)
271                          || slen > (noncelen + 32 + 16)))
272       || (!dek->use_aead && (slen < 17 || slen > 33)))
273     {
274       log_error ( _("weird size for an encrypted session key (%d)\n"),
275                   (int)slen);
276       return gpg_error (GPG_ERR_BAD_KEY);
277     }
278
279   err = openpgp_cipher_open (&hd, dek->algo, ciphermode, GCRY_CIPHER_SECURE);
280   if (!err)
281     err = gcry_cipher_setkey (hd, dek->key, dek->keylen);
282   if (!err)
283     err = gcry_cipher_setiv (hd, noncelen? seskey : NULL, noncelen);
284   if (err)
285     goto leave;
286
287   if (dek->use_aead)
288     {
289       byte ad[4];
290
291       ad[0] = (0xc0 | PKT_SYMKEY_ENC);
292       ad[1] = 5;
293       ad[2] = dek->algo;
294       ad[3] = dek->use_aead;
295       err = gcry_cipher_authenticate (hd, ad, 4);
296       if (err)
297         goto leave;
298       gcry_cipher_final (hd);
299       keylen = slen - noncelen - 16;
300       err = gcry_cipher_decrypt (hd, seskey+noncelen, keylen, NULL, 0);
301       if (err)
302         goto leave;
303       err = gcry_cipher_checktag (hd, seskey+noncelen+keylen, 16);
304       if (err)
305         goto leave;
306       /* Now we replace the dek components with the real session key to
307        * decrypt the contents of the sequencing packet. */
308       if (keylen > DIM(dek->key))
309         {
310           err = gpg_error (GPG_ERR_TOO_LARGE);
311           goto leave;
312         }
313       dek->keylen = keylen;
314       memcpy (dek->key, seskey + noncelen, dek->keylen);
315     }
316   else
317     {
318       gcry_cipher_decrypt (hd, seskey, slen, NULL, 0 );
319       /* Here we can only test whether the algo given in decrypted
320        * session key is a valid OpenPGP algo.  With 11 defined
321        * symmetric algorithms we will miss 4.3% of wrong passphrases
322        * here.  The actual checking is done later during bulk
323        * decryption; we can't bring this check forward easily.  We
324        * need to use the GPG_ERR_CHECKSUM so that we won't run into
325        * the gnupg < 2.2 bug compatible case which would terminate the
326        * process on GPG_ERR_CIPHER_ALGO.  Note that with AEAD (above)
327        * we will have a reliable test here.  */
328       if (openpgp_cipher_test_algo (seskey[0]))
329         {
330           err = gpg_error (GPG_ERR_CHECKSUM);
331           goto leave;
332         }
333
334       /* Now we replace the dek components with the real session key to
335        * decrypt the contents of the sequencing packet. */
336       keylen = slen-1;
337       if (keylen > DIM(dek->key))
338         {
339           err = gpg_error (GPG_ERR_TOO_LARGE);
340           goto leave;
341         }
342       dek->algo = seskey[0];
343       dek->keylen = keylen;
344       memcpy (dek->key, seskey + 1, dek->keylen);
345     }
346
347   /*log_hexdump( "thekey", dek->key, dek->keylen );*/
348
349  leave:
350   gcry_cipher_close (hd);
351   return err;
352 }
353
354
355 static void
356 proc_symkey_enc (CTX c, PACKET *pkt)
357 {
358   gpg_error_t err;
359   PKT_symkey_enc *enc;
360
361   enc = pkt->pkt.symkey_enc;
362   if (!enc)
363     log_error ("invalid symkey encrypted packet\n");
364   else if(!c->dek)
365     {
366       int algo = enc->cipher_algo;
367       const char *s = openpgp_cipher_algo_name (algo);
368       const char *a = (enc->aead_algo ? openpgp_aead_algo_name (enc->aead_algo)
369                        /**/           : "CFB");
370
371       if (!openpgp_cipher_test_algo (algo))
372         {
373           if (!opt.quiet)
374             {
375               if (enc->seskeylen)
376                 log_info (_("%s.%s encrypted session key\n"), s, a );
377               else
378                 log_info (_("%s.%s encrypted data\n"), s, a );
379             }
380         }
381       else
382         log_error (_("encrypted with unknown algorithm %d.%s\n"), algo, a);
383
384       if (openpgp_md_test_algo (enc->s2k.hash_algo))
385         {
386           log_error(_("passphrase generated with unknown digest"
387                       " algorithm %d\n"),enc->s2k.hash_algo);
388           s = NULL;
389         }
390
391       c->last_was_session_key = 2;
392       if (!s || opt.list_only)
393         goto leave;
394
395       if (opt.override_session_key)
396         {
397           c->dek = xmalloc_clear (sizeof *c->dek);
398           if (get_override_session_key (c->dek, opt.override_session_key))
399             {
400               xfree (c->dek);
401               c->dek = NULL;
402             }
403         }
404       else
405         {
406           c->dek = passphrase_to_dek (algo, &enc->s2k, 0, 0, NULL, NULL);
407           if (c->dek)
408             {
409               c->dek->symmetric = 1;
410               c->dek->use_aead = enc->aead_algo;
411
412               /* FIXME: This doesn't work perfectly if a symmetric key
413                  comes before a public key in the message - if the
414                  user doesn't know the passphrase, then there is a
415                  chance that the "decrypted" algorithm will happen to
416                  be a valid one, which will make the returned dek
417                  appear valid, so we won't try any public keys that
418                  come later. */
419               if (enc->seskeylen)
420                 {
421                   err = symkey_decrypt_seskey (c->dek,
422                                                enc->seskey, enc->seskeylen);
423                   if (err)
424                     {
425                       log_info ("decryption of the symmetrically encrypted"
426                                  " session key failed: %s\n",
427                                  gpg_strerror (err));
428                       if (gpg_err_code (err) != GPG_ERR_BAD_KEY
429                           && gpg_err_code (err) != GPG_ERR_CHECKSUM)
430                         log_fatal ("process terminated to be bug compatible"
431                                    " with GnuPG <= 2.2\n");
432                       if (c->dek->s2k_cacheid[0])
433                         {
434                           if (opt.debug)
435                             log_debug ("cleared passphrase cached with ID:"
436                                        " %s\n", c->dek->s2k_cacheid);
437                           passphrase_clear_cache (c->dek->s2k_cacheid);
438                         }
439                       xfree (c->dek);
440                       c->dek = NULL;
441                     }
442                 }
443               else
444                 c->dek->algo_info_printed = 1;
445             }
446         }
447     }
448
449  leave:
450   c->symkeys++;
451   free_packet (pkt, NULL);
452 }
453
454
455 static void
456 proc_pubkey_enc (CTX c, PACKET *pkt)
457 {
458   PKT_pubkey_enc *enc;
459
460   /* Check whether the secret key is available and store in this case.  */
461   c->last_was_session_key = 1;
462   enc = pkt->pkt.pubkey_enc;
463   /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
464   /* Hmmm: why do I have this algo check here - anyway there is
465    * function to check it. */
466   if (opt.verbose)
467     log_info (_("public key is %s\n"), keystr (enc->keyid));
468
469   if (is_status_enabled ())
470     {
471       char buf[50];
472       snprintf (buf, sizeof buf, "%08lX%08lX %d 0",
473                 (ulong)enc->keyid[0], (ulong)enc->keyid[1], enc->pubkey_algo);
474       write_status_text (STATUS_ENC_TO, buf);
475     }
476
477   if (!opt.list_only && !opt.override_session_key)
478     {
479       struct pubkey_enc_list *x = xmalloc (sizeof *x);
480
481       x->keyid[0] = enc->keyid[0];
482       x->keyid[1] = enc->keyid[1];
483       x->pubkey_algo = enc->pubkey_algo;
484       x->result = -1;
485       x->data[0] = x->data[1] = NULL;
486       if (enc->data[0])
487         {
488           x->data[0] = mpi_copy (enc->data[0]);
489           x->data[1] = mpi_copy (enc->data[1]);
490         }
491       x->next = c->pkenc_list;
492       c->pkenc_list = x;
493     }
494
495   free_packet(pkt, NULL);
496 }
497
498
499 /*
500  * Print the list of public key encrypted packets which we could
501  * not decrypt.
502  */
503 static void
504 print_pkenc_list (ctrl_t ctrl, struct pubkey_enc_list *list)
505 {
506   for (; list; list = list->next)
507     {
508       PKT_public_key *pk;
509       char pkstrbuf[PUBKEY_STRING_SIZE];
510       char *p;
511
512       pk = xmalloc_clear (sizeof *pk);
513
514       pk->pubkey_algo = list->pubkey_algo;
515       if (!get_pubkey (ctrl, pk, list->keyid))
516         {
517           pubkey_string (pk, pkstrbuf, sizeof pkstrbuf);
518
519           log_info (_("encrypted with %s key, ID %s, created %s\n"),
520                     pkstrbuf, keystr_from_pk (pk),
521                     strtimestamp (pk->timestamp));
522           p = get_user_id_native (ctrl, list->keyid);
523           log_printf (_("      \"%s\"\n"), p);
524           xfree (p);
525         }
526       else
527         log_info (_("encrypted with %s key, ID %s\n"),
528                   openpgp_pk_algo_name (list->pubkey_algo),
529                   keystr(list->keyid));
530
531       free_public_key (pk);
532     }
533 }
534
535
536 static void
537 proc_encrypted (CTX c, PACKET *pkt)
538 {
539   int result = 0;
540   int early_plaintext = literals_seen;
541
542   if (pkt->pkttype == PKT_ENCRYPTED_AEAD)
543     c->seen_pkt_encrypted_aead = 1;
544
545   if (early_plaintext)
546     {
547       log_info (_("WARNING: multiple plaintexts seen\n"));
548       write_status_errcode ("decryption.early_plaintext", GPG_ERR_BAD_DATA);
549       /* We fail only later so that we can print some more info first.  */
550     }
551
552   if (!opt.quiet)
553     {
554       if (c->symkeys>1)
555         log_info (_("encrypted with %lu passphrases\n"), c->symkeys);
556       else if (c->symkeys == 1)
557         log_info (_("encrypted with 1 passphrase\n"));
558       print_pkenc_list (c->ctrl, c->pkenc_list);
559     }
560
561   /* Figure out the session key by looking at all pkenc packets. */
562   if (opt.list_only || c->dek)
563     ;
564   else if (opt.override_session_key)
565     {
566       c->dek = xmalloc_clear (sizeof *c->dek);
567       result = get_override_session_key (c->dek, opt.override_session_key);
568       if (result)
569         {
570           xfree (c->dek);
571           c->dek = NULL;
572           log_info (_("public key decryption failed: %s\n"),
573                     gpg_strerror (result));
574           write_status_error ("pkdecrypt_failed", result);
575         }
576     }
577   else
578     {
579       c->dek = xmalloc_secure_clear (sizeof *c->dek);
580       result = get_session_key (c->ctrl, c->pkenc_list, c->dek);
581       if (is_status_enabled ())
582         {
583           struct pubkey_enc_list *list;
584
585           for (list = c->pkenc_list; list; list = list->next)
586             if (list->result == GPG_ERR_NO_SECKEY)
587               {
588                 char buf[20];
589                 snprintf (buf, sizeof buf, "%08lX%08lX",
590                           (ulong)list->keyid[0], (ulong)list->keyid[1]);
591                 write_status_text (STATUS_NO_SECKEY, buf);
592               }
593         }
594
595       if (result)
596         {
597           log_info (_("public key decryption failed: %s\n"),
598                     gpg_strerror (result));
599           write_status_error ("pkdecrypt_failed", result);
600
601           /* Error: Delete the DEK. */
602           xfree (c->dek);
603           c->dek = NULL;
604         }
605     }
606
607   if (c->dek && opt.verbose > 1)
608     log_info (_("public key encrypted data: good DEK\n"));
609
610   write_status (STATUS_BEGIN_DECRYPTION);
611
612   /*log_debug("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
613   if (opt.list_only)
614     result = -1;
615   else if (!c->dek && !c->last_was_session_key)
616     {
617       int algo;
618       STRING2KEY s2kbuf;
619       STRING2KEY *s2k = NULL;
620       int canceled;
621
622       if (opt.override_session_key)
623         {
624           c->dek = xmalloc_clear (sizeof *c->dek);
625           result = get_override_session_key (c->dek, opt.override_session_key);
626           if (result)
627             {
628               xfree (c->dek);
629               c->dek = NULL;
630             }
631         }
632       else
633         {
634           /* Assume this is old style conventional encrypted data. */
635           algo = opt.def_cipher_algo;
636           if (algo)
637             log_info (_("assuming %s encrypted data\n"),
638                       openpgp_cipher_algo_name (algo));
639           else if (openpgp_cipher_test_algo (CIPHER_ALGO_IDEA))
640             {
641               algo = opt.def_cipher_algo;
642               if (!algo)
643                 algo = opt.s2k_cipher_algo;
644               log_info (_("IDEA cipher unavailable, "
645                           "optimistically attempting to use %s instead\n"),
646                         openpgp_cipher_algo_name (algo));
647             }
648           else
649             {
650               algo = CIPHER_ALGO_IDEA;
651               if (!opt.s2k_digest_algo)
652                 {
653                   /* If no digest is given we assume SHA-1. */
654                   s2kbuf.mode = 0;
655                   s2kbuf.hash_algo = DIGEST_ALGO_SHA1;
656                   s2k = &s2kbuf;
657                 }
658               log_info (_("assuming %s encrypted data\n"), "IDEA");
659             }
660
661           c->dek = passphrase_to_dek (algo, s2k, 0, 0, NULL, &canceled);
662           if (c->dek)
663             c->dek->algo_info_printed = 1;
664           else if (canceled)
665             result = gpg_error (GPG_ERR_CANCELED);
666           else
667             result = gpg_error (GPG_ERR_INV_PASSPHRASE);
668         }
669     }
670   else if (!c->dek)
671     result = GPG_ERR_NO_SECKEY;
672
673   /* Compute compliance with CO_DE_VS.  */
674   if (!result && is_status_enabled ()
675       /* Symmetric encryption and asymmetric encryption voids compliance.  */
676       && (c->symkeys != !!c->pkenc_list )
677       /* Overriding session key voids compliance.  */
678       && !opt.override_session_key
679       /* Check symmetric cipher.  */
680       && gnupg_cipher_is_compliant (CO_DE_VS, c->dek->algo,
681                                     GCRY_CIPHER_MODE_CFB))
682     {
683       struct pubkey_enc_list *i;
684       int compliant = 1;
685       PKT_public_key *pk = xmalloc (sizeof *pk);
686
687       if ( !(c->pkenc_list || c->symkeys) )
688         log_debug ("%s: where else did the session key come from?\n", __func__);
689
690       /* Now check that every key used to encrypt the session key is
691        * compliant.  */
692       for (i = c->pkenc_list; i && compliant; i = i->next)
693         {
694           memset (pk, 0, sizeof *pk);
695           pk->pubkey_algo = i->pubkey_algo;
696           if (get_pubkey (c->ctrl, pk, i->keyid) != 0
697               || ! gnupg_pk_is_compliant (CO_DE_VS, pk->pubkey_algo, pk->pkey,
698                                           nbits_from_pk (pk), NULL))
699             compliant = 0;
700           release_public_key_parts (pk);
701         }
702
703       xfree (pk);
704
705       if (compliant)
706         write_status_strings (STATUS_DECRYPTION_COMPLIANCE_MODE,
707                               gnupg_status_compliance_flag (CO_DE_VS),
708                               NULL);
709
710     }
711
712   if (!result)
713     result = decrypt_data (c->ctrl, c, pkt->pkt.encrypted, c->dek );
714
715   /* Trigger the deferred error.  */
716   if (!result && early_plaintext)
717     result = gpg_error (GPG_ERR_BAD_DATA);
718
719   if (result == -1)
720     ;
721   else if (!result
722            && !opt.ignore_mdc_error
723            && !pkt->pkt.encrypted->mdc_method
724            && !pkt->pkt.encrypted->aead_algo)
725     {
726       /* The message has been decrypted but does not carry an MDC or
727        * uses AEAD encryption.  --ignore-mdc-error has also not been
728        * used.  To avoid attacks changing an MDC message to a non-MDC
729        * message, we fail here.  */
730       log_error (_("WARNING: message was not integrity protected\n"));
731       if (!pkt->pkt.encrypted->mdc_method
732           && (openpgp_cipher_get_algo_blklen (c->dek->algo) == 8
733               || c->dek->algo == CIPHER_ALGO_TWOFISH))
734         {
735           /* Before 2.2.8 we did not fail hard for a missing MDC if
736            * one of the old ciphers where used.  Although these cases
737            * are rare in practice we print a hint on how to decrypt
738            * such messages.  */
739           log_string
740             (GPGRT_LOGLVL_INFO,
741              _("Hint: If this message was created before the year 2003 it is\n"
742                "likely that this message is legitimate.  This is because back\n"
743                "then integrity protection was not widely used.\n"));
744           log_info (_("Use the option '%s' to decrypt anyway.\n"),
745                      "--ignore-mdc-error");
746           write_status_errcode ("nomdc_with_legacy_cipher",
747                                 GPG_ERR_DECRYPT_FAILED);
748         }
749       log_info (_("decryption forced to fail!\n"));
750       write_status (STATUS_DECRYPTION_FAILED);
751     }
752   else if (!result || (gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE
753                        && !pkt->pkt.encrypted->aead_algo
754                        && opt.ignore_mdc_error))
755     {
756       /* All is fine or for an MDC message the MDC failed but the
757        * --ignore-mdc-error option is active.  For compatibility
758        * reasons we issue GOODMDC also for AEAD messages.  */
759       write_status (STATUS_DECRYPTION_OKAY);
760       if (opt.verbose > 1)
761         log_info(_("decryption okay\n"));
762
763       if (pkt->pkt.encrypted->aead_algo)
764         write_status (STATUS_GOODMDC);
765       else if (pkt->pkt.encrypted->mdc_method && !result)
766         write_status (STATUS_GOODMDC);
767       else
768         log_info (_("WARNING: message was not integrity protected\n"));
769     }
770   else if (gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE
771            || gpg_err_code (result) == GPG_ERR_TRUNCATED)
772     {
773       glo_ctrl.lasterr = result;
774       log_error (_("WARNING: encrypted message has been manipulated!\n"));
775       write_status (STATUS_BADMDC);
776       write_status (STATUS_DECRYPTION_FAILED);
777     }
778   else
779     {
780       if ((gpg_err_code (result) == GPG_ERR_BAD_KEY
781            || gpg_err_code (result) == GPG_ERR_CHECKSUM
782            || gpg_err_code (result) == GPG_ERR_CIPHER_ALGO)
783           && *c->dek->s2k_cacheid != '\0')
784         {
785           if (opt.debug)
786             log_debug ("cleared passphrase cached with ID: %s\n",
787                        c->dek->s2k_cacheid);
788           passphrase_clear_cache (c->dek->s2k_cacheid);
789         }
790       glo_ctrl.lasterr = result;
791       write_status (STATUS_DECRYPTION_FAILED);
792       log_error (_("decryption failed: %s\n"), gpg_strerror (result));
793       /* Hmmm: does this work when we have encrypted using multiple
794        * ways to specify the session key (symmmetric and PK). */
795     }
796
797   xfree (c->dek);
798   c->dek = NULL;
799   free_packet (pkt, NULL);
800   c->last_was_session_key = 0;
801   write_status (STATUS_END_DECRYPTION);
802
803   /* Bump the counter even if we have not seen a literal data packet
804    * inside an encryption container.  This acts as a sentinel in case
805    * a misplace extra literal data packets follows after this
806    * encrypted packet.  */
807   literals_seen++;
808 }
809
810
811 static int
812 have_seen_pkt_encrypted_aead( CTX c )
813 {
814   CTX cc;
815
816   for (cc = c; cc; cc = cc->anchor)
817     {
818       if (cc->seen_pkt_encrypted_aead)
819         return 1;
820     }
821
822   return 0;
823 }
824
825
826 static void
827 proc_plaintext( CTX c, PACKET *pkt )
828 {
829   PKT_plaintext *pt = pkt->pkt.plaintext;
830   int any, clearsig, rc;
831   kbnode_t n;
832   unsigned char *extrahash;
833   size_t extrahashlen;
834
835   /* This is a literal data packet.  Bump a counter for later checks.  */
836   literals_seen++;
837
838   if (pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8))
839     log_info (_("Note: sender requested \"for-your-eyes-only\"\n"));
840   else if (opt.verbose)
841     {
842       /* We don't use print_utf8_buffer because that would require a
843        * string change which we don't want in 2.2.  It is also not
844        * clear whether the filename is always utf-8 encoded.  */
845       char *tmp = make_printable_string (pt->name, pt->namelen, 0);
846       log_info (_("original file name='%.*s'\n"), (int)strlen (tmp), tmp);
847       xfree (tmp);
848     }
849
850   free_md_filter_context (&c->mfx);
851   if (gcry_md_open (&c->mfx.md, 0, 0))
852     BUG ();
853   /* fixme: we may need to push the textfilter if we have sigclass 1
854    * and no armoring - Not yet tested
855    * Hmmm, why don't we need it at all if we have sigclass 1
856    * Should we assume that plaintext in mode 't' has always sigclass 1??
857    * See: Russ Allbery's mail 1999-02-09
858    */
859   any = clearsig = 0;
860   for (n=c->list; n; n = n->next )
861     {
862       if (n->pkt->pkttype == PKT_ONEPASS_SIG)
863         {
864           /* The onepass signature case. */
865           if (n->pkt->pkt.onepass_sig->digest_algo)
866             {
867               if (!opt.skip_verify)
868                 gcry_md_enable (c->mfx.md,
869                                 n->pkt->pkt.onepass_sig->digest_algo);
870
871               any = 1;
872             }
873         }
874       else if (n->pkt->pkttype == PKT_GPG_CONTROL
875                && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
876         {
877           /* The clearsigned message case. */
878           size_t datalen = n->pkt->pkt.gpg_control->datalen;
879           const byte *data = n->pkt->pkt.gpg_control->data;
880
881           /* Check that we have at least the sigclass and one hash.  */
882           if  (datalen < 2)
883             log_fatal ("invalid control packet CTRLPKT_CLEARSIGN_START\n");
884           /* Note that we don't set the clearsig flag for not-dash-escaped
885            * documents.  */
886           clearsig = (*data == 0x01);
887           for (data++, datalen--; datalen; datalen--, data++)
888             if (!opt.skip_verify)
889               gcry_md_enable (c->mfx.md, *data);
890           any = 1;
891           break;  /* Stop here as one-pass signature packets are not
892                      expected.  */
893         }
894       else if (n->pkt->pkttype == PKT_SIGNATURE)
895         {
896           /* The SIG+LITERAL case that PGP used to use.  */
897           if (!opt.skip_verify)
898             gcry_md_enable (c->mfx.md, n->pkt->pkt.signature->digest_algo);
899           any = 1;
900         }
901     }
902
903   if (!any && !opt.skip_verify && !have_seen_pkt_encrypted_aead(c))
904     {
905       /* This is for the old GPG LITERAL+SIG case.  It's not legal
906          according to 2440, so hopefully it won't come up that often.
907          There is no good way to specify what algorithms to use in
908          that case, so these there are the historical answer. */
909         gcry_md_enable (c->mfx.md, DIGEST_ALGO_RMD160);
910         gcry_md_enable (c->mfx.md, DIGEST_ALGO_SHA1);
911     }
912   if (DBG_HASHING)
913     {
914       gcry_md_debug (c->mfx.md, "verify");
915       if (c->mfx.md2)
916         gcry_md_debug (c->mfx.md2, "verify2");
917     }
918
919   rc=0;
920
921   if (literals_seen > 1)
922     {
923       log_info (_("WARNING: multiple plaintexts seen\n"));
924
925       write_status_text (STATUS_ERROR, "proc_pkt.plaintext 89_BAD_DATA");
926       log_inc_errorcount ();
927       rc = gpg_error (GPG_ERR_UNEXPECTED);
928     }
929
930   if (!rc)
931     {
932       /* It we are in --verify mode, we do not want to output the
933        * signed text.  However, if --output is also used we do what
934        * has been requested and write out the signed data.  */
935       rc = handle_plaintext (pt, &c->mfx,
936                              (opt.outfp || opt.outfile)? 0 :  c->sigs_only,
937                              clearsig);
938       if (gpg_err_code (rc) == GPG_ERR_EACCES && !c->sigs_only)
939         {
940           /* Can't write output but we hash it anyway to check the
941              signature. */
942           rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
943         }
944     }
945
946   if (rc)
947     log_error ("handle plaintext failed: %s\n", gpg_strerror (rc));
948
949   /* We add a marker control packet instead of the plaintext packet.
950    * This is so that we can later detect invalid packet sequences.
951    * The apcket is further used to convey extra data from the
952    * plaintext packet to the signature verification. */
953   extrahash = xtrymalloc (6 + pt->namelen);
954   if (!extrahash)
955     {
956       /* No way to return an error.  */
957       rc = gpg_error_from_syserror ();
958       log_error ("malloc failed in %s: %s\n", __func__, gpg_strerror (rc));
959       extrahashlen = 0;
960     }
961   else
962     {
963       extrahash[0] = pt->mode;
964       extrahash[1] = pt->namelen;
965       if (pt->namelen)
966         memcpy (extrahash+2, pt->name, pt->namelen);
967       extrahashlen = 2 + pt->namelen;
968       extrahash[extrahashlen++] = pt->timestamp >> 24;
969       extrahash[extrahashlen++] = pt->timestamp >> 16;
970       extrahash[extrahashlen++] = pt->timestamp >>  8;
971       extrahash[extrahashlen++] = pt->timestamp      ;
972     }
973
974   free_packet (pkt, NULL);
975   c->last_was_session_key = 0;
976
977   n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK,
978                                       extrahash, extrahashlen));
979   xfree (extrahash);
980   if (c->list)
981     add_kbnode (c->list, n);
982   else
983     c->list = n;
984 }
985
986
987 static int
988 proc_compressed_cb (iobuf_t a, void *info)
989 {
990   if ( ((CTX)info)->signed_data.used
991        && ((CTX)info)->signed_data.data_fd != -1)
992     return proc_signature_packets_by_fd (((CTX)info)->ctrl, info, a,
993                                          ((CTX)info)->signed_data.data_fd);
994   else
995     return proc_signature_packets (((CTX)info)->ctrl, info, a,
996                                    ((CTX)info)->signed_data.data_names,
997                                    ((CTX)info)->sigfilename );
998 }
999
1000
1001 static int
1002 proc_encrypt_cb (iobuf_t a, void *info )
1003 {
1004   CTX c = info;
1005   return proc_encryption_packets (c->ctrl, info, a );
1006 }
1007
1008
1009 static int
1010 proc_compressed (CTX c, PACKET *pkt)
1011 {
1012   PKT_compressed *zd = pkt->pkt.compressed;
1013   int rc;
1014
1015   /*printf("zip: compressed data packet\n");*/
1016   if (c->sigs_only)
1017     rc = handle_compressed (c->ctrl, c, zd, proc_compressed_cb, c);
1018   else if( c->encrypt_only )
1019     rc = handle_compressed (c->ctrl, c, zd, proc_encrypt_cb, c);
1020   else
1021     rc = handle_compressed (c->ctrl, c, zd, NULL, NULL);
1022
1023   if (gpg_err_code (rc) == GPG_ERR_BAD_DATA)
1024     {
1025       if  (!c->any.uncompress_failed)
1026         {
1027           CTX cc;
1028
1029           for (cc=c; cc; cc = cc->anchor)
1030             cc->any.uncompress_failed = 1;
1031           log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
1032         }
1033     }
1034   else if (rc)
1035     log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
1036
1037   free_packet (pkt, NULL);
1038   c->last_was_session_key = 0;
1039   return rc;
1040 }
1041
1042
1043 /*
1044  * Check the signature.  If R_PK is not NULL a copy of the public key
1045  * used to verify the signature will be stored there, or NULL if not
1046  * found.  Returns: 0 = valid signature or an error code
1047  */
1048 static int
1049 do_check_sig (CTX c, kbnode_t node, const void *extrahash, size_t extrahashlen,
1050               int *is_selfsig,
1051               int *is_expkey, int *is_revkey, PKT_public_key **r_pk)
1052 {
1053   PKT_signature *sig;
1054   gcry_md_hd_t md = NULL;
1055   gcry_md_hd_t md2 = NULL;
1056   gcry_md_hd_t md_good = NULL;
1057   int algo, rc;
1058
1059   if (r_pk)
1060     *r_pk = NULL;
1061
1062   log_assert (node->pkt->pkttype == PKT_SIGNATURE);
1063   if (is_selfsig)
1064     *is_selfsig = 0;
1065   sig = node->pkt->pkt.signature;
1066
1067   algo = sig->digest_algo;
1068   rc = openpgp_md_test_algo (algo);
1069   if (rc)
1070     return rc;
1071
1072   if (sig->sig_class == 0x00)
1073     {
1074       if (c->mfx.md)
1075         {
1076           if (gcry_md_copy (&md, c->mfx.md ))
1077             BUG ();
1078         }
1079       else /* detached signature */
1080         {
1081           /* check_signature() will enable the md. */
1082           if (gcry_md_open (&md, 0, 0 ))
1083             BUG ();
1084         }
1085     }
1086   else if (sig->sig_class == 0x01)
1087     {
1088       /* How do we know that we have to hash the (already hashed) text
1089          in canonical mode ??? (calculating both modes???) */
1090       if (c->mfx.md)
1091         {
1092           if (gcry_md_copy (&md, c->mfx.md ))
1093             BUG ();
1094           if (c->mfx.md2 && gcry_md_copy (&md2, c->mfx.md2))
1095             BUG ();
1096         }
1097       else /* detached signature */
1098         {
1099           log_debug ("Do we really need this here?");
1100           /* check_signature() will enable the md*/
1101           if (gcry_md_open (&md, 0, 0 ))
1102             BUG ();
1103           if (gcry_md_open (&md2, 0, 0 ))
1104             BUG ();
1105         }
1106     }
1107   else if ((sig->sig_class&~3) == 0x10
1108            ||   sig->sig_class == 0x18
1109            ||   sig->sig_class == 0x1f
1110            ||   sig->sig_class == 0x20
1111            ||   sig->sig_class == 0x28
1112            ||   sig->sig_class == 0x30)
1113     {
1114       if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
1115           || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1116         {
1117           return check_key_signature (c->ctrl, c->list, node, is_selfsig);
1118         }
1119       else if (sig->sig_class == 0x20)
1120         {
1121           log_error (_("standalone revocation - "
1122                        "use \"gpg --import\" to apply\n"));
1123           return GPG_ERR_NOT_PROCESSED;
1124         }
1125       else
1126         {
1127           log_error ("invalid root packet for sigclass %02x\n", sig->sig_class);
1128           return GPG_ERR_SIG_CLASS;
1129         }
1130     }
1131   else
1132     return GPG_ERR_SIG_CLASS;
1133
1134   /* We only get here if we are checking the signature of a binary
1135      (0x00) or text document (0x01).  */
1136   rc = check_signature2 (c->ctrl, sig, md, extrahash, extrahashlen,
1137                          NULL, is_expkey, is_revkey, r_pk);
1138   if (! rc)
1139     md_good = md;
1140   else if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE && md2)
1141     {
1142       PKT_public_key *pk2;
1143
1144       rc = check_signature2 (c->ctrl, sig, md2, extrahash, extrahashlen,
1145                              NULL, is_expkey, is_revkey,
1146                              r_pk? &pk2 : NULL);
1147       if (!rc)
1148         {
1149           md_good = md2;
1150           if (r_pk)
1151             {
1152               free_public_key (*r_pk);
1153               *r_pk = pk2;
1154             }
1155         }
1156     }
1157
1158   if (md_good)
1159     {
1160       unsigned char *buffer = gcry_md_read (md_good, sig->digest_algo);
1161       sig->digest_len = gcry_md_get_algo_dlen (map_md_openpgp_to_gcry (algo));
1162       memcpy (sig->digest, buffer, sig->digest_len);
1163     }
1164
1165   gcry_md_close (md);
1166   gcry_md_close (md2);
1167
1168   return rc;
1169 }
1170
1171
1172 static void
1173 print_userid (PACKET *pkt)
1174 {
1175   if (!pkt)
1176     BUG();
1177
1178   if (pkt->pkttype != PKT_USER_ID)
1179     {
1180       es_printf ("ERROR: unexpected packet type %d", pkt->pkttype );
1181       return;
1182     }
1183   if (opt.with_colons)
1184     {
1185       if (pkt->pkt.user_id->attrib_data)
1186         es_printf("%u %lu",
1187                   pkt->pkt.user_id->numattribs,
1188                   pkt->pkt.user_id->attrib_len);
1189       else
1190         es_write_sanitized (es_stdout, pkt->pkt.user_id->name,
1191                             pkt->pkt.user_id->len, ":", NULL);
1192     }
1193   else
1194     print_utf8_buffer (es_stdout, pkt->pkt.user_id->name,
1195                        pkt->pkt.user_id->len );
1196 }
1197
1198
1199 /*
1200  * List the keyblock in a user friendly way
1201  */
1202 static void
1203 list_node (CTX c, kbnode_t node)
1204 {
1205   if (!node)
1206     ;
1207   else if (node->pkt->pkttype == PKT_PUBLIC_KEY
1208            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1209     {
1210       PKT_public_key *pk = node->pkt->pkt.public_key;
1211
1212       if (opt.with_colons)
1213         {
1214           u32 keyid[2];
1215
1216           keyid_from_pk( pk, keyid );
1217           if (pk->flags.primary)
1218             c->trustletter = (opt.fast_list_mode
1219                               ? 0
1220                               : get_validity_info
1221                                   (c->ctrl,
1222                                    node->pkt->pkttype == PKT_PUBLIC_KEY
1223                                    ? node : NULL,
1224                                    pk, NULL));
1225           es_printf ("%s:", pk->flags.primary? "pub":"sub" );
1226           if (c->trustletter)
1227             es_putc (c->trustletter, es_stdout);
1228           es_printf (":%u:%d:%08lX%08lX:%s:%s::",
1229                      nbits_from_pk( pk ),
1230                      pk->pubkey_algo,
1231                      (ulong)keyid[0],(ulong)keyid[1],
1232                      colon_datestr_from_pk( pk ),
1233                      colon_strtime (pk->expiredate) );
1234           if (pk->flags.primary && !opt.fast_list_mode)
1235             es_putc (get_ownertrust_info (c->ctrl, pk, 1), es_stdout);
1236           es_putc (':', es_stdout);
1237           es_putc ('\n', es_stdout);
1238         }
1239       else
1240         {
1241           print_key_line (c->ctrl, es_stdout, pk, 0);
1242         }
1243
1244       if (opt.keyid_format == KF_NONE && !opt.with_colons)
1245         ; /* Already printed.  */
1246       else if ((pk->flags.primary && opt.fingerprint) || opt.fingerprint > 1)
1247         print_fingerprint (c->ctrl, NULL, pk, 0);
1248
1249       if (pk->flags.primary)
1250         {
1251           int kl = opt.keyid_format == KF_NONE? 0 : keystrlen ();
1252
1253           /* Now list all userids with their signatures. */
1254           for (node = node->next; node; node = node->next)
1255             {
1256               if (node->pkt->pkttype == PKT_SIGNATURE)
1257                 {
1258                   list_node (c,  node );
1259                 }
1260               else if (node->pkt->pkttype == PKT_USER_ID)
1261                 {
1262                   if (opt.with_colons)
1263                     es_printf ("%s:::::::::",
1264                                node->pkt->pkt.user_id->attrib_data?"uat":"uid");
1265                   else
1266                     es_printf ("uid%*s",
1267                                kl + (opt.legacy_list_mode? 9:11),
1268                                "" );
1269                   print_userid (node->pkt);
1270                   if (opt.with_colons)
1271                     es_putc (':', es_stdout);
1272                   es_putc ('\n', es_stdout);
1273                 }
1274               else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1275                 {
1276                   list_node(c,  node );
1277                 }
1278             }
1279         }
1280     }
1281   else if (node->pkt->pkttype == PKT_SECRET_KEY
1282            || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1283     {
1284
1285       log_debug ("FIXME: No way to print secret key packets here\n");
1286       /* fixme: We may use a function to turn a secret key packet into
1287          a public key one and use that here.  */
1288     }
1289   else if (node->pkt->pkttype == PKT_SIGNATURE)
1290     {
1291       PKT_signature *sig = node->pkt->pkt.signature;
1292       int is_selfsig = 0;
1293       int rc2 = 0;
1294       size_t n;
1295       char *p;
1296       int sigrc = ' ';
1297
1298       if (!opt.verbose)
1299         return;
1300
1301       if (sig->sig_class == 0x20 || sig->sig_class == 0x30)
1302         es_fputs ("rev", es_stdout);
1303       else
1304         es_fputs ("sig", es_stdout);
1305       if (opt.check_sigs)
1306         {
1307           fflush (stdout);
1308           rc2 = do_check_sig (c, node, NULL, 0, &is_selfsig, NULL, NULL, NULL);
1309           switch (gpg_err_code (rc2))
1310             {
1311             case 0:                       sigrc = '!'; break;
1312             case GPG_ERR_BAD_SIGNATURE:   sigrc = '-'; break;
1313             case GPG_ERR_NO_PUBKEY:
1314             case GPG_ERR_UNUSABLE_PUBKEY: sigrc = '?'; break;
1315             default:                      sigrc = '%'; break;
1316             }
1317         }
1318       else /* Check whether this is a self signature.  */
1319         {
1320           u32 keyid[2];
1321
1322           if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
1323               || c->list->pkt->pkttype == PKT_SECRET_KEY )
1324             {
1325               keyid_from_pk (c->list->pkt->pkt.public_key, keyid);
1326
1327               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
1328                 is_selfsig = 1;
1329             }
1330         }
1331
1332       if (opt.with_colons)
1333         {
1334           es_putc (':', es_stdout);
1335           if (sigrc != ' ')
1336             es_putc (sigrc, es_stdout);
1337           es_printf ("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1338                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1339                      colon_datestr_from_sig (sig),
1340                      colon_expirestr_from_sig (sig));
1341
1342           if (sig->trust_depth || sig->trust_value)
1343             es_printf ("%d %d",sig->trust_depth,sig->trust_value);
1344           es_putc (':', es_stdout);
1345
1346           if (sig->trust_regexp)
1347             es_write_sanitized (es_stdout, sig->trust_regexp,
1348                                 strlen (sig->trust_regexp), ":", NULL);
1349           es_putc (':', es_stdout);
1350         }
1351       else
1352         es_printf ("%c       %s %s   ",
1353                    sigrc, keystr (sig->keyid), datestr_from_sig(sig));
1354       if (sigrc == '%')
1355         es_printf ("[%s] ", gpg_strerror (rc2) );
1356       else if (sigrc == '?')
1357         ;
1358       else if (is_selfsig)
1359         {
1360           if (opt.with_colons)
1361             es_putc (':', es_stdout);
1362           es_fputs (sig->sig_class == 0x18? "[keybind]":"[selfsig]", es_stdout);
1363           if (opt.with_colons)
1364             es_putc (':', es_stdout);
1365         }
1366       else if (!opt.fast_list_mode)
1367         {
1368           p = get_user_id (c->ctrl, sig->keyid, &n, NULL);
1369           es_write_sanitized (es_stdout, p, n,
1370                               opt.with_colons?":":NULL, NULL );
1371           xfree (p);
1372         }
1373       if (opt.with_colons)
1374         es_printf (":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1375       es_putc ('\n', es_stdout);
1376     }
1377   else
1378     log_error ("invalid node with packet of type %d\n", node->pkt->pkttype);
1379 }
1380
1381
1382 int
1383 proc_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1384 {
1385   int rc;
1386   CTX c = xmalloc_clear (sizeof *c);
1387
1388   c->ctrl = ctrl;
1389   c->anchor = anchor;
1390   rc = do_proc_packets (c, a);
1391   xfree (c);
1392
1393   return rc;
1394 }
1395
1396
1397 int
1398 proc_signature_packets (ctrl_t ctrl, void *anchor, iobuf_t a,
1399                         strlist_t signedfiles, const char *sigfilename )
1400 {
1401   CTX c = xmalloc_clear (sizeof *c);
1402   int rc;
1403
1404   c->ctrl = ctrl;
1405   c->anchor = anchor;
1406   c->sigs_only = 1;
1407
1408   c->signed_data.data_fd = -1;
1409   c->signed_data.data_names = signedfiles;
1410   c->signed_data.used = !!signedfiles;
1411
1412   c->sigfilename = sigfilename;
1413   rc = do_proc_packets (c, a);
1414
1415   /* If we have not encountered any signature we print an error
1416      messages, send a NODATA status back and return an error code.
1417      Using log_error is required because verify_files does not check
1418      error codes for each file but we want to terminate the process
1419      with an error. */
1420   if (!rc && !c->any.sig_seen)
1421     {
1422       write_status_text (STATUS_NODATA, "4");
1423       log_error (_("no signature found\n"));
1424       rc = GPG_ERR_NO_DATA;
1425     }
1426
1427   /* Propagate the signature seen flag upward. Do this only on success
1428      so that we won't issue the nodata status several times.  */
1429   if (!rc && c->anchor && c->any.sig_seen)
1430     c->anchor->any.sig_seen = 1;
1431
1432   xfree (c);
1433   return rc;
1434 }
1435
1436
1437 int
1438 proc_signature_packets_by_fd (ctrl_t ctrl,
1439                               void *anchor, iobuf_t a, int signed_data_fd )
1440 {
1441   int rc;
1442   CTX c;
1443
1444   c = xtrycalloc (1, sizeof *c);
1445   if (!c)
1446     return gpg_error_from_syserror ();
1447
1448   c->ctrl = ctrl;
1449   c->anchor = anchor;
1450   c->sigs_only = 1;
1451
1452   c->signed_data.data_fd = signed_data_fd;
1453   c->signed_data.data_names = NULL;
1454   c->signed_data.used = (signed_data_fd != -1);
1455
1456   rc = do_proc_packets (c, a);
1457
1458   /* If we have not encountered any signature we print an error
1459      messages, send a NODATA status back and return an error code.
1460      Using log_error is required because verify_files does not check
1461      error codes for each file but we want to terminate the process
1462      with an error. */
1463   if (!rc && !c->any.sig_seen)
1464     {
1465       write_status_text (STATUS_NODATA, "4");
1466       log_error (_("no signature found\n"));
1467       rc = gpg_error (GPG_ERR_NO_DATA);
1468     }
1469
1470   /* Propagate the signature seen flag upward. Do this only on success
1471      so that we won't issue the nodata status several times. */
1472   if (!rc && c->anchor && c->any.sig_seen)
1473     c->anchor->any.sig_seen = 1;
1474
1475   xfree ( c );
1476   return rc;
1477 }
1478
1479
1480 int
1481 proc_encryption_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1482 {
1483   CTX c = xmalloc_clear (sizeof *c);
1484   int rc;
1485
1486   c->ctrl = ctrl;
1487   c->anchor = anchor;
1488   c->encrypt_only = 1;
1489   rc = do_proc_packets (c, a);
1490   xfree (c);
1491   return rc;
1492 }
1493
1494
1495 static int
1496 check_nesting (CTX c)
1497 {
1498   int level;
1499
1500   for (level=0; c; c = c->anchor)
1501     level++;
1502
1503   if (level > MAX_NESTING_DEPTH)
1504     {
1505       log_error ("input data with too deeply nested packets\n");
1506       write_status_text (STATUS_UNEXPECTED, "1");
1507       return GPG_ERR_BAD_DATA;
1508     }
1509
1510   return 0;
1511 }
1512
1513
1514 static int
1515 do_proc_packets (CTX c, iobuf_t a)
1516 {
1517   PACKET *pkt;
1518   struct parse_packet_ctx_s parsectx;
1519   int rc = 0;
1520   int any_data = 0;
1521   int newpkt;
1522
1523   rc = check_nesting (c);
1524   if (rc)
1525     return rc;
1526
1527   pkt = xmalloc( sizeof *pkt );
1528   c->iobuf = a;
1529   init_packet(pkt);
1530   init_parse_packet (&parsectx, a);
1531   while ((rc=parse_packet (&parsectx, pkt)) != -1)
1532     {
1533       any_data = 1;
1534       if (rc)
1535         {
1536           free_packet (pkt, &parsectx);
1537           /* Stop processing when an invalid packet has been encountered
1538            * but don't do so when we are doing a --list-packets.  */
1539           if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
1540               && opt.list_packets == 0)
1541             break;
1542           continue;
1543         }
1544       newpkt = -1;
1545       if (opt.list_packets)
1546         {
1547           switch (pkt->pkttype)
1548             {
1549             case PKT_PUBKEY_ENC:    proc_pubkey_enc (c, pkt); break;
1550             case PKT_SYMKEY_ENC:    proc_symkey_enc (c, pkt); break;
1551             case PKT_ENCRYPTED:
1552             case PKT_ENCRYPTED_MDC:
1553             case PKT_ENCRYPTED_AEAD:proc_encrypted (c, pkt); break;
1554             case PKT_COMPRESSED:    rc = proc_compressed (c, pkt); break;
1555             default: newpkt = 0; break;
1556             }
1557         }
1558       else if (c->sigs_only)
1559         {
1560           switch (pkt->pkttype)
1561             {
1562             case PKT_PUBLIC_KEY:
1563             case PKT_SECRET_KEY:
1564             case PKT_USER_ID:
1565             case PKT_SYMKEY_ENC:
1566             case PKT_PUBKEY_ENC:
1567             case PKT_ENCRYPTED:
1568             case PKT_ENCRYPTED_MDC:
1569             case PKT_ENCRYPTED_AEAD:
1570               write_status_text( STATUS_UNEXPECTED, "0" );
1571               rc = GPG_ERR_UNEXPECTED;
1572               goto leave;
1573
1574             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1575             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1576             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1577             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1578             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1579             default: newpkt = 0; break;
1580             }
1581         }
1582       else if (c->encrypt_only)
1583         {
1584           switch (pkt->pkttype)
1585             {
1586             case PKT_PUBLIC_KEY:
1587             case PKT_SECRET_KEY:
1588             case PKT_USER_ID:
1589               write_status_text (STATUS_UNEXPECTED, "0");
1590               rc = GPG_ERR_UNEXPECTED;
1591               goto leave;
1592
1593             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1594             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1595             case PKT_PUBKEY_ENC:  proc_pubkey_enc (c, pkt); break;
1596             case PKT_ENCRYPTED:
1597             case PKT_ENCRYPTED_MDC:
1598             case PKT_ENCRYPTED_AEAD: proc_encrypted (c, pkt); break;
1599             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1600             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1601             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1602             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1603             default: newpkt = 0; break;
1604             }
1605         }
1606       else
1607         {
1608           switch (pkt->pkttype)
1609             {
1610             case PKT_PUBLIC_KEY:
1611             case PKT_SECRET_KEY:
1612               release_list (c);
1613               c->list = new_kbnode (pkt);
1614               newpkt = 1;
1615               break;
1616             case PKT_PUBLIC_SUBKEY:
1617             case PKT_SECRET_SUBKEY:
1618               newpkt = add_subkey (c, pkt);
1619               break;
1620             case PKT_USER_ID:     newpkt = add_user_id (c, pkt); break;
1621             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1622             case PKT_PUBKEY_ENC:  proc_pubkey_enc (c, pkt); break;
1623             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1624             case PKT_ENCRYPTED:
1625             case PKT_ENCRYPTED_MDC:
1626             case PKT_ENCRYPTED_AEAD: proc_encrypted (c, pkt); break;
1627             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1628             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1629             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1630             case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1631             case PKT_RING_TRUST:  newpkt = add_ring_trust (c, pkt); break;
1632             default: newpkt = 0; break;
1633             }
1634         }
1635
1636       if (rc)
1637         goto leave;
1638
1639       /* This is a very ugly construct and frankly, I don't remember why
1640        * I used it.  Adding the MDC check here is a hack.
1641        * The right solution is to initiate another context for encrypted
1642        * packet and not to reuse the current one ...  It works right
1643        * when there is a compression packet between which adds just
1644        * an extra layer.
1645        * Hmmm: Rewrite this whole module here??
1646        */
1647       if (pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC)
1648         c->any.data = (pkt->pkttype == PKT_PLAINTEXT);
1649
1650       if (newpkt == -1)
1651         ;
1652       else if (newpkt)
1653         {
1654           pkt = xmalloc (sizeof *pkt);
1655           init_packet (pkt);
1656         }
1657       else
1658         free_packet (pkt, &parsectx);
1659     }
1660
1661   if (rc == GPG_ERR_INV_PACKET)
1662     write_status_text (STATUS_NODATA, "3");
1663
1664   if (any_data)
1665     rc = 0;
1666   else if (rc == -1)
1667     write_status_text (STATUS_NODATA, "2");
1668
1669
1670  leave:
1671   release_list (c);
1672   xfree(c->dek);
1673   free_packet (pkt, &parsectx);
1674   deinit_parse_packet (&parsectx);
1675   xfree (pkt);
1676   free_md_filter_context (&c->mfx);
1677   return rc;
1678 }
1679
1680
1681 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1682    of the notation data. */
1683 static pka_info_t *
1684 get_pka_address (PKT_signature *sig)
1685 {
1686   pka_info_t *pka = NULL;
1687   struct notation *nd,*notation;
1688
1689   notation=sig_to_notation(sig);
1690
1691   for(nd=notation;nd;nd=nd->next)
1692     {
1693       if(strcmp(nd->name,"pka-address@gnupg.org")!=0)
1694         continue; /* Not the notation we want. */
1695
1696       /* For now we only use the first valid PKA notation. In future
1697          we might want to keep additional PKA notations in a linked
1698          list. */
1699       if (is_valid_mailbox (nd->value))
1700         {
1701           pka = xmalloc (sizeof *pka + strlen(nd->value));
1702           pka->valid = 0;
1703           pka->checked = 0;
1704           pka->uri = NULL;
1705           strcpy (pka->email, nd->value);
1706           break;
1707         }
1708     }
1709
1710   free_notation(notation);
1711
1712   return pka;
1713 }
1714
1715
1716 /* Return the URI from a DNS PKA record.  If this record has already
1717    be retrieved for the signature we merely return it; if not we go
1718    out and try to get that DNS record. */
1719 static const char *
1720 pka_uri_from_sig (CTX c, PKT_signature *sig)
1721 {
1722   if (!sig->flags.pka_tried)
1723     {
1724       log_assert (!sig->pka_info);
1725       sig->flags.pka_tried = 1;
1726       sig->pka_info = get_pka_address (sig);
1727       if (sig->pka_info)
1728         {
1729           char *url;
1730           unsigned char *fpr;
1731           size_t fprlen;
1732
1733           if (!gpg_dirmngr_get_pka (c->ctrl, sig->pka_info->email,
1734                                     &fpr, &fprlen, &url))
1735             {
1736               if (fpr && fprlen == sizeof sig->pka_info->fpr)
1737                 {
1738                   memcpy (sig->pka_info->fpr, fpr, fprlen);
1739                   if (url)
1740                     {
1741                       sig->pka_info->valid = 1;
1742                       if (!*url)
1743                         xfree (url);
1744                       else
1745                         sig->pka_info->uri = url;
1746                       url = NULL;
1747                     }
1748                 }
1749               xfree (fpr);
1750               xfree (url);
1751             }
1752         }
1753     }
1754   return sig->pka_info? sig->pka_info->uri : NULL;
1755 }
1756
1757
1758 /* Return true if the AKL has the WKD method specified.  */
1759 static int
1760 akl_has_wkd_method (void)
1761 {
1762   struct akl *akl;
1763
1764   for (akl = opt.auto_key_locate; akl; akl = akl->next)
1765     if (akl->type == AKL_WKD)
1766       return 1;
1767   return 0;
1768 }
1769
1770
1771 /* Return the ISSUER fingerprint buffer and its length at R_LEN.
1772  * Returns NULL if not available.  The returned buffer is valid as
1773  * long as SIG is not modified.  */
1774 const byte *
1775 issuer_fpr_raw (PKT_signature *sig, size_t *r_len)
1776 {
1777   const byte *p;
1778   size_t n;
1779
1780   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_ISSUER_FPR, &n);
1781   if (p && ((n == 21 && p[0] == 4) || (n == 33 && p[0] == 5)))
1782     {
1783       *r_len = n - 1;
1784       return p+1;
1785     }
1786   *r_len = 0;
1787   return NULL;
1788 }
1789
1790
1791 /* Return the ISSUER fingerprint string in human readable format if
1792  * available.  Caller must release the string.  */
1793 /* FIXME: Move to another file.  */
1794 char *
1795 issuer_fpr_string (PKT_signature *sig)
1796 {
1797   const byte *p;
1798   size_t n;
1799
1800   p = issuer_fpr_raw (sig, &n);
1801   return p? bin2hex (p, n, NULL) : NULL;
1802 }
1803
1804
1805 static void
1806 print_good_bad_signature (int statno, const char *keyid_str, kbnode_t un,
1807                           PKT_signature *sig, int rc)
1808 {
1809   char *p;
1810
1811   write_status_text_and_buffer (statno, keyid_str,
1812                                 un? un->pkt->pkt.user_id->name:"[?]",
1813                                 un? un->pkt->pkt.user_id->len:3,
1814                                 -1);
1815
1816   if (un)
1817     p = utf8_to_native (un->pkt->pkt.user_id->name,
1818                         un->pkt->pkt.user_id->len, 0);
1819   else
1820     p = xstrdup ("[?]");
1821
1822   if (rc)
1823     log_info (_("BAD signature from \"%s\""), p);
1824   else if (sig->flags.expired)
1825     log_info (_("Expired signature from \"%s\""), p);
1826   else
1827     log_info (_("Good signature from \"%s\""), p);
1828
1829   xfree (p);
1830 }
1831
1832
1833 static int
1834 check_sig_and_print (CTX c, kbnode_t node)
1835 {
1836   PKT_signature *sig = node->pkt->pkt.signature;
1837   const char *astr;
1838   int rc;
1839   int is_expkey = 0;
1840   int is_revkey = 0;
1841   char *issuer_fpr = NULL;
1842   PKT_public_key *pk = NULL;  /* The public key for the signature or NULL. */
1843   int tried_ks_by_fpr;
1844   const void *extrahash = NULL;
1845   size_t extrahashlen = 0;
1846
1847   if (opt.skip_verify)
1848     {
1849       log_info(_("signature verification suppressed\n"));
1850       return 0;
1851     }
1852
1853   /* Check that the message composition is valid.
1854    *
1855    * Per RFC-2440bis (-15) allowed:
1856    *
1857    * S{1,n}           -- detached signature.
1858    * S{1,n} P         -- old style PGP2 signature
1859    * O{1,n} P S{1,n}  -- standard OpenPGP signature.
1860    * C P S{1,n}       -- cleartext signature.
1861    *
1862    *
1863    *      O = One-Pass Signature packet.
1864    *      S = Signature packet.
1865    *      P = OpenPGP Message packet (Encrypted | Compressed | Literal)
1866    *             (Note that the current rfc2440bis draft also allows
1867    *              for a signed message but that does not work as it
1868    *              introduces ambiguities.)
1869    *          We keep track of these packages using the marker packet
1870    *          CTRLPKT_PLAINTEXT_MARK.
1871    *      C = Marker packet for cleartext signatures.
1872    *
1873    * We reject all other messages.
1874    *
1875    * Actually we are calling this too often, i.e. for verification of
1876    * each message but better have some duplicate work than to silently
1877    * introduce a bug here.
1878    */
1879   {
1880     kbnode_t n;
1881     int n_onepass, n_sig;
1882
1883 /*     log_debug ("checking signature packet composition\n"); */
1884 /*     dump_kbnode (c->list); */
1885
1886     n = c->list;
1887     log_assert (n);
1888     if ( n->pkt->pkttype == PKT_SIGNATURE )
1889       {
1890         /* This is either "S{1,n}" case (detached signature) or
1891            "S{1,n} P" (old style PGP2 signature). */
1892         for (n = n->next; n; n = n->next)
1893           if (n->pkt->pkttype != PKT_SIGNATURE)
1894             break;
1895         if (!n)
1896           ; /* Okay, this is a detached signature.  */
1897         else if (n->pkt->pkttype == PKT_GPG_CONTROL
1898                  && (n->pkt->pkt.gpg_control->control
1899                      == CTRLPKT_PLAINTEXT_MARK) )
1900           {
1901             if (n->next)
1902               goto ambiguous;  /* We only allow one P packet. */
1903             extrahash = n->pkt->pkt.gpg_control->data;
1904             extrahashlen = n->pkt->pkt.gpg_control->datalen;
1905           }
1906         else
1907           goto ambiguous;
1908       }
1909     else if (n->pkt->pkttype == PKT_ONEPASS_SIG)
1910       {
1911         /* This is the "O{1,n} P S{1,n}" case (standard signature). */
1912         for (n_onepass=1, n = n->next;
1913              n && n->pkt->pkttype == PKT_ONEPASS_SIG; n = n->next)
1914           n_onepass++;
1915         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1916                     && (n->pkt->pkt.gpg_control->control
1917                         == CTRLPKT_PLAINTEXT_MARK)))
1918           goto ambiguous;
1919         extrahash = n->pkt->pkt.gpg_control->data;
1920         extrahashlen = n->pkt->pkt.gpg_control->datalen;
1921
1922         for (n_sig=0, n = n->next;
1923              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1924           n_sig++;
1925         if (!n_sig)
1926           goto ambiguous;
1927
1928         /* If we wanted to disallow multiple sig verification, we'd do
1929          * something like this:
1930          *
1931          * if (n)
1932          *   goto ambiguous;
1933          *
1934          * However, this can stay allowable as we can't get here.  */
1935
1936         if (n_onepass != n_sig)
1937           {
1938             log_info ("number of one-pass packets does not match "
1939                       "number of signature packets\n");
1940             goto ambiguous;
1941           }
1942       }
1943     else if (n->pkt->pkttype == PKT_GPG_CONTROL
1944              && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
1945       {
1946         /* This is the "C P S{1,n}" case (clear text signature). */
1947         n = n->next;
1948         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1949                     && (n->pkt->pkt.gpg_control->control
1950                         == CTRLPKT_PLAINTEXT_MARK)))
1951           goto ambiguous;
1952         extrahash = n->pkt->pkt.gpg_control->data;
1953         extrahashlen = n->pkt->pkt.gpg_control->datalen;
1954         for (n_sig=0, n = n->next;
1955              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1956           n_sig++;
1957         if (n || !n_sig)
1958           goto ambiguous;
1959       }
1960     else
1961       {
1962       ambiguous:
1963         log_error(_("can't handle this ambiguous signature data\n"));
1964         return 0;
1965       }
1966   }
1967
1968   if (sig->signers_uid)
1969     write_status_buffer (STATUS_NEWSIG,
1970                          sig->signers_uid, strlen (sig->signers_uid), 0);
1971   else
1972     write_status_text (STATUS_NEWSIG, NULL);
1973
1974   astr = openpgp_pk_algo_name ( sig->pubkey_algo );
1975   issuer_fpr = issuer_fpr_string (sig);
1976
1977   if (issuer_fpr)
1978     {
1979       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1980       log_info (_("               using %s key %s\n"),
1981                 astr? astr: "?", issuer_fpr);
1982
1983     }
1984   else if (!keystrlen () || keystrlen () > 8)
1985     {
1986       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1987       log_info (_("               using %s key %s\n"),
1988                 astr? astr: "?", keystr(sig->keyid));
1989     }
1990   else /* Legacy format.  */
1991     log_info (_("Signature made %s using %s key ID %s\n"),
1992               asctimestamp(sig->timestamp), astr? astr: "?",
1993               keystr(sig->keyid));
1994
1995   /* In verbose mode print the signers UID.  */
1996   if (sig->signers_uid)
1997     log_info (_("               issuer \"%s\"\n"), sig->signers_uid);
1998
1999   rc = do_check_sig (c, node, extrahash, extrahashlen,
2000                      NULL, &is_expkey, &is_revkey, &pk);
2001
2002   /* If the key isn't found, check for a preferred keyserver.  */
2003   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY && sig->flags.pref_ks)
2004     {
2005       const byte *p;
2006       int seq = 0;
2007       size_t n;
2008
2009       while ((p=enum_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
2010         {
2011           /* According to my favorite copy editor, in English grammar,
2012              you say "at" if the key is located on a web page, but
2013              "from" if it is located on a keyserver.  I'm not going to
2014              even try to make two strings here :) */
2015           log_info(_("Key available at: ") );
2016           print_utf8_buffer (log_get_stream(), p, n);
2017           log_printf ("\n");
2018
2019           if (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
2020               && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
2021             {
2022               struct keyserver_spec *spec;
2023
2024               spec = parse_preferred_keyserver (sig);
2025               if (spec)
2026                 {
2027                   int res;
2028
2029                   free_public_key (pk);
2030                   pk = NULL;
2031                   glo_ctrl.in_auto_key_retrieve++;
2032                   res = keyserver_import_keyid (c->ctrl, sig->keyid,spec, 1);
2033                   glo_ctrl.in_auto_key_retrieve--;
2034                   if (!res)
2035                     rc = do_check_sig (c, node, extrahash, extrahashlen,
2036                                        NULL, &is_expkey, &is_revkey, &pk);
2037                   free_keyserver_spec (spec);
2038
2039                   if (!rc)
2040                     break;
2041                 }
2042             }
2043         }
2044     }
2045
2046   /* If the avove methods didn't work, our next try is to use the URI
2047    * from a DNS PKA record.  */
2048   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2049       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
2050       && (opt.keyserver_options.options & KEYSERVER_HONOR_PKA_RECORD))
2051     {
2052       const char *uri = pka_uri_from_sig (c, sig);
2053
2054       if (uri)
2055         {
2056           /* FIXME: We might want to locate the key using the
2057              fingerprint instead of the keyid. */
2058           int res;
2059           struct keyserver_spec *spec;
2060
2061           spec = parse_keyserver_uri (uri, 1);
2062           if (spec)
2063             {
2064               free_public_key (pk);
2065               pk = NULL;
2066               glo_ctrl.in_auto_key_retrieve++;
2067               res = keyserver_import_keyid (c->ctrl, sig->keyid, spec, 1);
2068               glo_ctrl.in_auto_key_retrieve--;
2069               free_keyserver_spec (spec);
2070               if (!res)
2071                 rc = do_check_sig (c, node, extrahash, extrahashlen,
2072                                    NULL, &is_expkey, &is_revkey, &pk);
2073             }
2074         }
2075     }
2076
2077   /* If the above methods didn't work, our next try is to locate
2078    * the key via its fingerprint from a keyserver.  This requires
2079    * that the signers fingerprint is encoded in the signature.  We
2080    * favor this over the WKD method (to be tried next), because an
2081    * arbitrary keyserver is less subject to web bug like monitoring.  */
2082   tried_ks_by_fpr = 0;
2083   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2084       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
2085       && keyserver_any_configured (c->ctrl))
2086     {
2087       int res;
2088       const byte *p;
2089       size_t n;
2090
2091       p = issuer_fpr_raw (sig, &n);
2092       if (p)
2093         {
2094           /* v4 or v5 packet with a SHA-1/256 fingerprint.  */
2095           free_public_key (pk);
2096           pk = NULL;
2097           glo_ctrl.in_auto_key_retrieve++;
2098           res = keyserver_import_fprint (c->ctrl, p, n, opt.keyserver, 1);
2099           tried_ks_by_fpr = 1;
2100           glo_ctrl.in_auto_key_retrieve--;
2101           if (!res)
2102             rc = do_check_sig (c, node, extrahash, extrahashlen,
2103                                NULL, &is_expkey, &is_revkey, &pk);
2104         }
2105     }
2106
2107   /* If the above methods didn't work, our next try is to retrieve the
2108    * key from the WKD. */
2109   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2110       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
2111       && !opt.flags.disable_signer_uid
2112       && akl_has_wkd_method ()
2113       && sig->signers_uid)
2114     {
2115       int res;
2116
2117       free_public_key (pk);
2118       pk = NULL;
2119       glo_ctrl.in_auto_key_retrieve++;
2120       res = keyserver_import_wkd (c->ctrl, sig->signers_uid, 1, NULL, NULL);
2121       glo_ctrl.in_auto_key_retrieve--;
2122       /* Fixme: If the fingerprint is embedded in the signature,
2123        * compare it to the fingerprint of the returned key.  */
2124       if (!res)
2125         rc = do_check_sig (c, node, extrahash, extrahashlen,
2126                            NULL, &is_expkey, &is_revkey, &pk);
2127     }
2128
2129   /* If the above methods did't work, our next try is to use a
2130    * keyserver.  */
2131   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2132       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
2133       && !tried_ks_by_fpr
2134       && keyserver_any_configured (c->ctrl))
2135     {
2136       int res;
2137
2138       free_public_key (pk);
2139       pk = NULL;
2140       glo_ctrl.in_auto_key_retrieve++;
2141       res = keyserver_import_keyid (c->ctrl, sig->keyid, opt.keyserver, 1);
2142       glo_ctrl.in_auto_key_retrieve--;
2143       if (!res)
2144         rc = do_check_sig (c, node, extrahash, extrahashlen,
2145                            NULL, &is_expkey, &is_revkey, &pk);
2146     }
2147
2148   if (!rc || gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
2149     {
2150       kbnode_t un, keyblock;
2151       int count = 0;
2152       int statno;
2153       char keyid_str[50];
2154       PKT_public_key *mainpk = NULL;
2155
2156       if (rc)
2157         statno = STATUS_BADSIG;
2158       else if (sig->flags.expired)
2159         statno = STATUS_EXPSIG;
2160       else if (is_expkey)
2161         statno = STATUS_EXPKEYSIG;
2162       else if(is_revkey)
2163         statno = STATUS_REVKEYSIG;
2164       else
2165         statno = STATUS_GOODSIG;
2166
2167       /* FIXME: We should have the public key in PK and thus the
2168        * keyblock has already been fetched.  Thus we could use the
2169        * fingerprint or PK itself to lookup the entire keyblock.  That
2170        * would best be done with a cache.  */
2171       keyblock = get_pubkeyblock_for_sig (c->ctrl, sig);
2172
2173       snprintf (keyid_str, sizeof keyid_str, "%08lX%08lX [uncertain] ",
2174                 (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
2175
2176       /* Find and print the primary user ID along with the
2177          "Good|Expired|Bad signature" line.  */
2178       for (un=keyblock; un; un = un->next)
2179         {
2180           int valid;
2181
2182           if (un->pkt->pkttype==PKT_PUBLIC_KEY)
2183             {
2184               mainpk = un->pkt->pkt.public_key;
2185               continue;
2186             }
2187           if (un->pkt->pkttype != PKT_USER_ID)
2188             continue;
2189           if (!un->pkt->pkt.user_id->created)
2190             continue;
2191           if (un->pkt->pkt.user_id->flags.revoked)
2192             continue;
2193           if (un->pkt->pkt.user_id->flags.expired)
2194             continue;
2195           if (!un->pkt->pkt.user_id->flags.primary)
2196             continue;
2197           /* We want the textual primary user ID here */
2198           if (un->pkt->pkt.user_id->attrib_data)
2199             continue;
2200
2201           log_assert (mainpk);
2202
2203           /* Since this is just informational, don't actually ask the
2204              user to update any trust information.  (Note: we register
2205              the signature later.)  Because print_good_bad_signature
2206              does not print a LF we need to compute the validity
2207              before calling that function.  */
2208           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2209             valid = get_validity (c->ctrl, keyblock, mainpk,
2210                                   un->pkt->pkt.user_id, NULL, 0);
2211           else
2212             valid = 0; /* Not used.  */
2213
2214           keyid_str[17] = 0; /* cut off the "[uncertain]" part */
2215
2216           print_good_bad_signature (statno, keyid_str, un, sig, rc);
2217
2218           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2219             log_printf (" [%s]\n",trust_value_to_string(valid));
2220           else
2221             log_printf ("\n");
2222
2223           count++;
2224         }
2225
2226       log_assert (mainpk);
2227
2228       /* In case we did not found a valid textual userid above
2229          we print the first user id packet or a "[?]" instead along
2230          with the "Good|Expired|Bad signature" line.  */
2231       if (!count)
2232         {
2233           /* Try for an invalid textual userid */
2234           for (un=keyblock; un; un = un->next)
2235             {
2236               if (un->pkt->pkttype == PKT_USER_ID
2237                   && !un->pkt->pkt.user_id->attrib_data)
2238                 break;
2239             }
2240
2241           /* Try for any userid at all */
2242           if (!un)
2243             {
2244               for (un=keyblock; un; un = un->next)
2245                 {
2246                   if (un->pkt->pkttype == PKT_USER_ID)
2247                     break;
2248                 }
2249             }
2250
2251           if (opt.trust_model==TM_ALWAYS || !un)
2252             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
2253
2254           print_good_bad_signature (statno, keyid_str, un, sig, rc);
2255
2256           if (opt.trust_model != TM_ALWAYS && un)
2257             log_printf (" %s",_("[uncertain]") );
2258           log_printf ("\n");
2259         }
2260
2261       /* If we have a good signature and already printed
2262        * the primary user ID, print all the other user IDs */
2263       if (count
2264           && !rc
2265           && !(opt.verify_options & VERIFY_SHOW_PRIMARY_UID_ONLY))
2266         {
2267           char *p;
2268           for( un=keyblock; un; un = un->next)
2269             {
2270               if (un->pkt->pkttype != PKT_USER_ID)
2271                 continue;
2272               if ((un->pkt->pkt.user_id->flags.revoked
2273                    || un->pkt->pkt.user_id->flags.expired)
2274                   && !(opt.verify_options & VERIFY_SHOW_UNUSABLE_UIDS))
2275                 continue;
2276               /* Skip textual primary user ids which we printed above. */
2277               if (un->pkt->pkt.user_id->flags.primary
2278                   && !un->pkt->pkt.user_id->attrib_data )
2279                 continue;
2280
2281               /* If this user id has attribute data, print that.  */
2282               if (un->pkt->pkt.user_id->attrib_data)
2283                 {
2284                   dump_attribs (un->pkt->pkt.user_id, mainpk);
2285
2286                   if (opt.verify_options&VERIFY_SHOW_PHOTOS)
2287                     show_photos (c->ctrl,
2288                                  un->pkt->pkt.user_id->attribs,
2289                                  un->pkt->pkt.user_id->numattribs,
2290                                  mainpk ,un->pkt->pkt.user_id);
2291                 }
2292
2293               p = utf8_to_native (un->pkt->pkt.user_id->name,
2294                                   un->pkt->pkt.user_id->len, 0);
2295               log_info (_("                aka \"%s\""), p);
2296               xfree (p);
2297
2298               if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2299                 {
2300                   const char *valid;
2301
2302                   if (un->pkt->pkt.user_id->flags.revoked)
2303                     valid = _("revoked");
2304                   else if (un->pkt->pkt.user_id->flags.expired)
2305                     valid = _("expired");
2306                   else
2307                     /* Since this is just informational, don't
2308                        actually ask the user to update any trust
2309                        information.  */
2310                     valid = (trust_value_to_string
2311                              (get_validity (c->ctrl, keyblock, mainpk,
2312                                             un->pkt->pkt.user_id, NULL, 0)));
2313                   log_printf (" [%s]\n",valid);
2314                 }
2315               else
2316                 log_printf ("\n");
2317             }
2318         }
2319
2320       /* For good signatures print notation data.  */
2321       if (!rc)
2322         {
2323           if ((opt.verify_options & VERIFY_SHOW_POLICY_URLS))
2324             show_policy_url (sig, 0, 1);
2325           else
2326             show_policy_url (sig, 0, 2);
2327
2328           if ((opt.verify_options & VERIFY_SHOW_KEYSERVER_URLS))
2329             show_keyserver_url (sig, 0, 1);
2330           else
2331             show_keyserver_url (sig, 0, 2);
2332
2333           if ((opt.verify_options & VERIFY_SHOW_NOTATIONS))
2334             show_notation
2335               (sig, 0, 1,
2336                (((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)
2337                 + ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0)));
2338           else
2339             show_notation (sig, 0, 2, 0);
2340         }
2341
2342       /* For good signatures print the VALIDSIG status line.  */
2343       if (!rc && is_status_enabled () && pk)
2344         {
2345           char pkhex[MAX_FINGERPRINT_LEN*2+1];
2346           char mainpkhex[MAX_FINGERPRINT_LEN*2+1];
2347
2348           hexfingerprint (pk, pkhex, sizeof pkhex);
2349           hexfingerprint (mainpk, mainpkhex, sizeof mainpkhex);
2350
2351           /* TODO: Replace the reserved '0' in the field below with
2352              bits for status flags (policy url, notation, etc.).  */
2353           write_status_printf (STATUS_VALIDSIG,
2354                                "%s %s %lu %lu %d 0 %d %d %02X %s",
2355                                pkhex,
2356                                strtimestamp (sig->timestamp),
2357                                (ulong)sig->timestamp,
2358                                (ulong)sig->expiredate,
2359                                sig->version, sig->pubkey_algo,
2360                                sig->digest_algo,
2361                                sig->sig_class,
2362                                mainpkhex);
2363         }
2364
2365       /* Print compliance warning for Good signatures.  */
2366       if (!rc && pk && !opt.quiet
2367           && !gnupg_pk_is_compliant (opt.compliance, pk->pubkey_algo,
2368                                      pk->pkey, nbits_from_pk (pk), NULL))
2369         {
2370           log_info (_("WARNING: This key is not suitable for signing"
2371                       " in %s mode\n"),
2372                     gnupg_compliance_option_string (opt.compliance));
2373         }
2374
2375       /* For good signatures compute and print the trust information.
2376          Note that in the Tofu trust model this may ask the user on
2377          how to resolve a conflict.  */
2378       if (!rc)
2379         {
2380           if ((opt.verify_options & VERIFY_PKA_LOOKUPS))
2381             pka_uri_from_sig (c, sig); /* Make sure PKA info is available. */
2382           rc = check_signatures_trust (c->ctrl, sig);
2383         }
2384
2385       /* Print extra information about the signature.  */
2386       if (sig->flags.expired)
2387         {
2388           log_info (_("Signature expired %s\n"), asctimestamp(sig->expiredate));
2389           rc = GPG_ERR_GENERAL; /* Need a better error here?  */
2390         }
2391       else if (sig->expiredate)
2392         log_info (_("Signature expires %s\n"), asctimestamp(sig->expiredate));
2393
2394       if (opt.verbose)
2395         {
2396           char pkstrbuf[PUBKEY_STRING_SIZE];
2397
2398           if (pk)
2399             pubkey_string (pk, pkstrbuf, sizeof pkstrbuf);
2400           else
2401             *pkstrbuf = 0;
2402
2403           log_info (_("%s signature, digest algorithm %s%s%s\n"),
2404                     sig->sig_class==0x00?_("binary"):
2405                     sig->sig_class==0x01?_("textmode"):_("unknown"),
2406                     gcry_md_algo_name (sig->digest_algo),
2407                     *pkstrbuf?_(", key algorithm "):"", pkstrbuf);
2408         }
2409
2410       /* Print final warnings.  */
2411       if (!rc && !c->signed_data.used)
2412         {
2413           /* Signature is basically good but we test whether the
2414              deprecated command
2415                gpg --verify FILE.sig
2416              was used instead of
2417                gpg --verify FILE.sig FILE
2418              to verify a detached signature.  If we figure out that a
2419              data file with a matching name exists, we print a warning.
2420
2421              The problem is that the first form would also verify a
2422              standard signature.  This behavior could be used to
2423              create a made up .sig file for a tarball by creating a
2424              standard signature from a valid detached signature packet
2425              (for example from a signed git tag).  Then replace the
2426              sig file on the FTP server along with a changed tarball.
2427              Using the first form the verify command would correctly
2428              verify the signature but don't even consider the tarball.  */
2429           kbnode_t n;
2430           char *dfile;
2431
2432           dfile = get_matching_datafile (c->sigfilename);
2433           if (dfile)
2434             {
2435               for (n = c->list; n; n = n->next)
2436                 if (n->pkt->pkttype != PKT_SIGNATURE)
2437                   break;
2438               if (n)
2439                 {
2440                   /* Not only signature packets in the tree thus this
2441                      is not a detached signature.  */
2442                   log_info (_("WARNING: not a detached signature; "
2443                               "file '%s' was NOT verified!\n"), dfile);
2444                 }
2445               xfree (dfile);
2446             }
2447         }
2448
2449       /* Compute compliance with CO_DE_VS.  */
2450       if (pk && is_status_enabled ()
2451           && gnupg_pk_is_compliant (CO_DE_VS, pk->pubkey_algo, pk->pkey,
2452                                     nbits_from_pk (pk), NULL)
2453           && gnupg_digest_is_compliant (CO_DE_VS, sig->digest_algo))
2454         write_status_strings (STATUS_VERIFICATION_COMPLIANCE_MODE,
2455                               gnupg_status_compliance_flag (CO_DE_VS),
2456                               NULL);
2457
2458       free_public_key (pk);
2459       pk = NULL;
2460       release_kbnode( keyblock );
2461       if (rc)
2462         g10_errors_seen = 1;
2463       if (opt.batch && rc)
2464         g10_exit (1);
2465     }
2466   else
2467     {
2468       write_status_printf (STATUS_ERRSIG, "%08lX%08lX %d %d %02x %lu %d %s",
2469                            (ulong)sig->keyid[0], (ulong)sig->keyid[1],
2470                            sig->pubkey_algo, sig->digest_algo,
2471                            sig->sig_class, (ulong)sig->timestamp,
2472                            gpg_err_code (rc),
2473                            issuer_fpr? issuer_fpr:"-");
2474       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
2475         {
2476           write_status_printf (STATUS_NO_PUBKEY, "%08lX%08lX",
2477                                (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
2478         }
2479       if (gpg_err_code (rc) != GPG_ERR_NOT_PROCESSED)
2480         log_error (_("Can't check signature: %s\n"), gpg_strerror (rc));
2481     }
2482
2483   free_public_key (pk);
2484   xfree (issuer_fpr);
2485   return rc;
2486 }
2487
2488
2489 /*
2490  * Process the tree which starts at node
2491  */
2492 static void
2493 proc_tree (CTX c, kbnode_t node)
2494 {
2495   kbnode_t n1;
2496   int rc;
2497
2498   if (opt.list_packets || opt.list_only)
2499     return;
2500
2501   /* We must skip our special plaintext marker packets here because
2502      they may be the root packet.  These packets are only used in
2503      additional checks and skipping them here doesn't matter.  */
2504   while (node
2505          && node->pkt->pkttype == PKT_GPG_CONTROL
2506           && node->pkt->pkt.gpg_control->control == CTRLPKT_PLAINTEXT_MARK)
2507     {
2508       node = node->next;
2509     }
2510   if (!node)
2511     return;
2512
2513   c->trustletter = ' ';
2514   if (node->pkt->pkttype == PKT_PUBLIC_KEY
2515       || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2516     {
2517       merge_keys_and_selfsig (c->ctrl, node);
2518       list_node (c, node);
2519     }
2520   else if (node->pkt->pkttype == PKT_SECRET_KEY)
2521     {
2522       merge_keys_and_selfsig (c->ctrl, node);
2523       list_node (c, node);
2524     }
2525   else if (node->pkt->pkttype == PKT_ONEPASS_SIG)
2526     {
2527       /* Check all signatures.  */
2528       if (!c->any.data)
2529         {
2530           int use_textmode = 0;
2531
2532           free_md_filter_context (&c->mfx);
2533           /* Prepare to create all requested message digests.  */
2534           rc = gcry_md_open (&c->mfx.md, 0, 0);
2535           if (rc)
2536             goto hash_err;
2537
2538           /* Fixme: why looking for the signature packet and not the
2539              one-pass packet?  */
2540           for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2541             gcry_md_enable (c->mfx.md, n1->pkt->pkt.signature->digest_algo);
2542
2543           if (n1 && n1->pkt->pkt.onepass_sig->sig_class == 0x01)
2544             use_textmode = 1;
2545
2546           /* Ask for file and hash it. */
2547           if (c->sigs_only)
2548             {
2549               if (c->signed_data.used && c->signed_data.data_fd != -1)
2550                 rc = hash_datafile_by_fd (c->mfx.md, NULL,
2551                                           c->signed_data.data_fd,
2552                                           use_textmode);
2553               else
2554                 rc = hash_datafiles (c->mfx.md, NULL,
2555                                      c->signed_data.data_names,
2556                                      c->sigfilename,
2557                                      use_textmode);
2558             }
2559           else
2560             {
2561               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2562                                               iobuf_get_real_fname (c->iobuf),
2563                                               use_textmode);
2564             }
2565
2566         hash_err:
2567           if (rc)
2568             {
2569               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2570               return;
2571             }
2572         }
2573       else if (c->signed_data.used)
2574         {
2575           log_error (_("not a detached signature\n"));
2576           return;
2577         }
2578
2579       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2580         check_sig_and_print (c, n1);
2581
2582     }
2583   else if (node->pkt->pkttype == PKT_GPG_CONTROL
2584            && node->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
2585     {
2586       /* Clear text signed message.  */
2587       if (!c->any.data)
2588         {
2589           log_error ("cleartext signature without data\n");
2590           return;
2591         }
2592       else if (c->signed_data.used)
2593         {
2594           log_error (_("not a detached signature\n"));
2595           return;
2596         }
2597
2598       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2599         check_sig_and_print (c, n1);
2600
2601     }
2602   else if (node->pkt->pkttype == PKT_SIGNATURE)
2603     {
2604       PKT_signature *sig = node->pkt->pkt.signature;
2605       int multiple_ok = 1;
2606
2607       n1 = find_next_kbnode (node, PKT_SIGNATURE);
2608       if (n1)
2609         {
2610           byte class = sig->sig_class;
2611           byte hash  = sig->digest_algo;
2612
2613           for (; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2614             {
2615               /* We can't currently handle multiple signatures of
2616                * different classes (we'd pretty much have to run a
2617                * different hash context for each), but if they are all
2618                * the same and it is detached signature, we make an
2619                * exception.  Note that the old code also disallowed
2620                * multiple signatures if the digest algorithms are
2621                * different.  We softened this restriction only for
2622                * detached signatures, to be on the safe side. */
2623               if (n1->pkt->pkt.signature->sig_class != class
2624                   || (c->any.data
2625                       && n1->pkt->pkt.signature->digest_algo != hash))
2626                 {
2627                   multiple_ok = 0;
2628                   log_info (_("WARNING: multiple signatures detected.  "
2629                               "Only the first will be checked.\n"));
2630                   break;
2631                 }
2632             }
2633         }
2634
2635       if (sig->sig_class != 0x00 && sig->sig_class != 0x01)
2636         {
2637           log_info(_("standalone signature of class 0x%02x\n"), sig->sig_class);
2638         }
2639       else if (!c->any.data)
2640         {
2641           /* Detached signature */
2642           free_md_filter_context (&c->mfx);
2643           rc = gcry_md_open (&c->mfx.md, sig->digest_algo, 0);
2644           if (rc)
2645             goto detached_hash_err;
2646
2647           if (multiple_ok)
2648             {
2649               /* If we have and want to handle multiple signatures we
2650                * need to enable all hash algorithms for the context.  */
2651               for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE)); )
2652                 if (!openpgp_md_test_algo (n1->pkt->pkt.signature->digest_algo))
2653                   gcry_md_enable (c->mfx.md,
2654                                   map_md_openpgp_to_gcry
2655                                   (n1->pkt->pkt.signature->digest_algo));
2656             }
2657
2658           if (RFC2440 || RFC4880)
2659             ; /* Strict RFC mode.  */
2660           else if (sig->digest_algo == DIGEST_ALGO_SHA1
2661                    && sig->pubkey_algo == PUBKEY_ALGO_DSA
2662                    && sig->sig_class == 0x01)
2663             {
2664               /* Enable a workaround for a pgp5 bug when the detached
2665                * signature has been created in textmode.  Note that we
2666                * do not implement this for multiple signatures with
2667                * different hash algorithms. */
2668               rc = gcry_md_open (&c->mfx.md2, sig->digest_algo, 0);
2669               if (rc)
2670                 goto detached_hash_err;
2671             }
2672
2673           /* Here we used to have another hack to work around a pgp
2674            * 2 bug: It worked by not using the textmode for detached
2675            * signatures; this would let the first signature check
2676            * (on md) fail but the second one (on md2), which adds an
2677            * extra CR would then have produced the "correct" hash.
2678            * This is very, very ugly hack but it may haved help in
2679            * some cases (and break others).
2680            *     c->mfx.md2? 0 :(sig->sig_class == 0x01)
2681            */
2682
2683           if (DBG_HASHING)
2684             {
2685               gcry_md_debug (c->mfx.md, "verify");
2686               if (c->mfx.md2)
2687                 gcry_md_debug (c->mfx.md2, "verify2");
2688             }
2689
2690           if (c->sigs_only)
2691             {
2692               if (c->signed_data.used && c->signed_data.data_fd != -1)
2693                 rc = hash_datafile_by_fd (c->mfx.md, c->mfx.md2,
2694                                           c->signed_data.data_fd,
2695                                           (sig->sig_class == 0x01));
2696               else
2697                 rc = hash_datafiles (c->mfx.md, c->mfx.md2,
2698                                      c->signed_data.data_names,
2699                                      c->sigfilename,
2700                                      (sig->sig_class == 0x01));
2701             }
2702           else
2703             {
2704               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2705                                               iobuf_get_real_fname(c->iobuf),
2706                                               (sig->sig_class == 0x01));
2707             }
2708
2709         detached_hash_err:
2710           if (rc)
2711             {
2712               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2713               return;
2714             }
2715         }
2716       else if (c->signed_data.used)
2717         {
2718           log_error (_("not a detached signature\n"));
2719           return;
2720         }
2721       else if (!opt.quiet)
2722         log_info (_("old style (PGP 2.x) signature\n"));
2723
2724       if (multiple_ok)
2725         {
2726           for (n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2727             check_sig_and_print (c, n1);
2728         }
2729       else
2730         check_sig_and_print (c, node);
2731
2732     }
2733   else
2734     {
2735       dump_kbnode (c->list);
2736       log_error ("invalid root packet detected in proc_tree()\n");
2737       dump_kbnode (node);
2738     }
2739 }