gpg: Report STATUS_NO_SECKEY when it is examined.
[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       const char *algstr;
510
511       algstr = openpgp_pk_algo_name (list->pubkey_algo);
512       pk = xmalloc_clear (sizeof *pk);
513
514       if (!algstr)
515         algstr = "[?]";
516       pk->pubkey_algo = list->pubkey_algo;
517       if (!get_pubkey (ctrl, pk, list->keyid))
518         {
519           char *p;
520           log_info (_("encrypted with %u-bit %s key, ID %s, created %s\n"),
521                     nbits_from_pk (pk), algstr, keystr_from_pk(pk),
522                     strtimestamp (pk->timestamp));
523           p = get_user_id_native (ctrl, list->keyid);
524           log_printf (_("      \"%s\"\n"), p);
525           xfree (p);
526         }
527       else
528         log_info (_("encrypted with %s key, ID %s\n"),
529                   algstr, 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
833   /* This is a literal data packet.  Bump a counter for later checks.  */
834   literals_seen++;
835
836   if (pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8))
837     log_info (_("Note: sender requested \"for-your-eyes-only\"\n"));
838   else if (opt.verbose)
839     {
840       /* We don't use print_utf8_buffer because that would require a
841        * string change which we don't want in 2.2.  It is also not
842        * clear whether the filename is always utf-8 encoded.  */
843       char *tmp = make_printable_string (pt->name, pt->namelen, 0);
844       log_info (_("original file name='%.*s'\n"), (int)strlen (tmp), tmp);
845       xfree (tmp);
846     }
847
848   free_md_filter_context (&c->mfx);
849   if (gcry_md_open (&c->mfx.md, 0, 0))
850     BUG ();
851   /* fixme: we may need to push the textfilter if we have sigclass 1
852    * and no armoring - Not yet tested
853    * Hmmm, why don't we need it at all if we have sigclass 1
854    * Should we assume that plaintext in mode 't' has always sigclass 1??
855    * See: Russ Allbery's mail 1999-02-09
856    */
857   any = clearsig = 0;
858   for (n=c->list; n; n = n->next )
859     {
860       if (n->pkt->pkttype == PKT_ONEPASS_SIG)
861         {
862           /* The onepass signature case. */
863           if (n->pkt->pkt.onepass_sig->digest_algo)
864             {
865               if (!opt.skip_verify)
866                 gcry_md_enable (c->mfx.md,
867                                 n->pkt->pkt.onepass_sig->digest_algo);
868
869               any = 1;
870             }
871         }
872       else if (n->pkt->pkttype == PKT_GPG_CONTROL
873                && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
874         {
875           /* The clearsigned message case. */
876           size_t datalen = n->pkt->pkt.gpg_control->datalen;
877           const byte *data = n->pkt->pkt.gpg_control->data;
878
879           /* Check that we have at least the sigclass and one hash.  */
880           if  (datalen < 2)
881             log_fatal ("invalid control packet CTRLPKT_CLEARSIGN_START\n");
882           /* Note that we don't set the clearsig flag for not-dash-escaped
883            * documents.  */
884           clearsig = (*data == 0x01);
885           for (data++, datalen--; datalen; datalen--, data++)
886             if (!opt.skip_verify)
887               gcry_md_enable (c->mfx.md, *data);
888           any = 1;
889           break;  /* Stop here as one-pass signature packets are not
890                      expected.  */
891         }
892       else if (n->pkt->pkttype == PKT_SIGNATURE)
893         {
894           /* The SIG+LITERAL case that PGP used to use.  */
895           if (!opt.skip_verify)
896             gcry_md_enable (c->mfx.md, n->pkt->pkt.signature->digest_algo);
897           any = 1;
898         }
899     }
900
901   if (!any && !opt.skip_verify && !have_seen_pkt_encrypted_aead(c))
902     {
903       /* This is for the old GPG LITERAL+SIG case.  It's not legal
904          according to 2440, so hopefully it won't come up that often.
905          There is no good way to specify what algorithms to use in
906          that case, so these there are the historical answer. */
907         gcry_md_enable (c->mfx.md, DIGEST_ALGO_RMD160);
908         gcry_md_enable (c->mfx.md, DIGEST_ALGO_SHA1);
909     }
910   if (DBG_HASHING)
911     {
912       gcry_md_debug (c->mfx.md, "verify");
913       if (c->mfx.md2)
914         gcry_md_debug (c->mfx.md2, "verify2");
915     }
916
917   rc=0;
918
919   if (literals_seen > 1)
920     {
921       log_info (_("WARNING: multiple plaintexts seen\n"));
922
923       write_status_text (STATUS_ERROR, "proc_pkt.plaintext 89_BAD_DATA");
924       log_inc_errorcount ();
925       rc = gpg_error (GPG_ERR_UNEXPECTED);
926     }
927
928   if (!rc)
929     {
930       /* It we are in --verify mode, we do not want to output the
931        * signed text.  However, if --output is also used we do what
932        * has been requested and write out the signed data.  */
933       rc = handle_plaintext (pt, &c->mfx,
934                              (opt.outfp || opt.outfile)? 0 :  c->sigs_only,
935                              clearsig);
936       if (gpg_err_code (rc) == GPG_ERR_EACCES && !c->sigs_only)
937         {
938           /* Can't write output but we hash it anyway to check the
939              signature. */
940           rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
941         }
942     }
943
944   if (rc)
945     log_error ("handle plaintext failed: %s\n", gpg_strerror (rc));
946
947   free_packet (pkt, NULL);
948   c->last_was_session_key = 0;
949
950   /* We add a marker control packet instead of the plaintext packet.
951    * This is so that we can later detect invalid packet sequences.  */
952   n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
953   if (c->list)
954     add_kbnode (c->list, n);
955   else
956     c->list = n;
957 }
958
959
960 static int
961 proc_compressed_cb (iobuf_t a, void *info)
962 {
963   if ( ((CTX)info)->signed_data.used
964        && ((CTX)info)->signed_data.data_fd != -1)
965     return proc_signature_packets_by_fd (((CTX)info)->ctrl, info, a,
966                                          ((CTX)info)->signed_data.data_fd);
967   else
968     return proc_signature_packets (((CTX)info)->ctrl, info, a,
969                                    ((CTX)info)->signed_data.data_names,
970                                    ((CTX)info)->sigfilename );
971 }
972
973
974 static int
975 proc_encrypt_cb (iobuf_t a, void *info )
976 {
977   CTX c = info;
978   return proc_encryption_packets (c->ctrl, info, a );
979 }
980
981
982 static int
983 proc_compressed (CTX c, PACKET *pkt)
984 {
985   PKT_compressed *zd = pkt->pkt.compressed;
986   int rc;
987
988   /*printf("zip: compressed data packet\n");*/
989   if (c->sigs_only)
990     rc = handle_compressed (c->ctrl, c, zd, proc_compressed_cb, c);
991   else if( c->encrypt_only )
992     rc = handle_compressed (c->ctrl, c, zd, proc_encrypt_cb, c);
993   else
994     rc = handle_compressed (c->ctrl, c, zd, NULL, NULL);
995
996   if (gpg_err_code (rc) == GPG_ERR_BAD_DATA)
997     {
998       if  (!c->any.uncompress_failed)
999         {
1000           CTX cc;
1001
1002           for (cc=c; cc; cc = cc->anchor)
1003             cc->any.uncompress_failed = 1;
1004           log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
1005         }
1006     }
1007   else if (rc)
1008     log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
1009
1010   free_packet (pkt, NULL);
1011   c->last_was_session_key = 0;
1012   return rc;
1013 }
1014
1015
1016 /*
1017  * Check the signature.  If R_PK is not NULL a copy of the public key
1018  * used to verify the signature will be stored there, or NULL if not
1019  * found.  Returns: 0 = valid signature or an error code
1020  */
1021 static int
1022 do_check_sig (CTX c, kbnode_t node, int *is_selfsig,
1023               int *is_expkey, int *is_revkey, PKT_public_key **r_pk)
1024 {
1025   PKT_signature *sig;
1026   gcry_md_hd_t md = NULL;
1027   gcry_md_hd_t md2 = NULL;
1028   gcry_md_hd_t md_good = NULL;
1029   int algo, rc;
1030
1031   if (r_pk)
1032     *r_pk = NULL;
1033
1034   log_assert (node->pkt->pkttype == PKT_SIGNATURE);
1035   if (is_selfsig)
1036     *is_selfsig = 0;
1037   sig = node->pkt->pkt.signature;
1038
1039   algo = sig->digest_algo;
1040   rc = openpgp_md_test_algo (algo);
1041   if (rc)
1042     return rc;
1043
1044   if (sig->sig_class == 0x00)
1045     {
1046       if (c->mfx.md)
1047         {
1048           if (gcry_md_copy (&md, c->mfx.md ))
1049             BUG ();
1050         }
1051       else /* detached signature */
1052         {
1053           /* check_signature() will enable the md. */
1054           if (gcry_md_open (&md, 0, 0 ))
1055             BUG ();
1056         }
1057     }
1058   else if (sig->sig_class == 0x01)
1059     {
1060       /* How do we know that we have to hash the (already hashed) text
1061          in canonical mode ??? (calculating both modes???) */
1062       if (c->mfx.md)
1063         {
1064           if (gcry_md_copy (&md, c->mfx.md ))
1065             BUG ();
1066           if (c->mfx.md2 && gcry_md_copy (&md2, c->mfx.md2))
1067             BUG ();
1068         }
1069       else /* detached signature */
1070         {
1071           log_debug ("Do we really need this here?");
1072           /* check_signature() will enable the md*/
1073           if (gcry_md_open (&md, 0, 0 ))
1074             BUG ();
1075           if (gcry_md_open (&md2, 0, 0 ))
1076             BUG ();
1077         }
1078     }
1079   else if ((sig->sig_class&~3) == 0x10
1080            ||   sig->sig_class == 0x18
1081            ||   sig->sig_class == 0x1f
1082            ||   sig->sig_class == 0x20
1083            ||   sig->sig_class == 0x28
1084            ||   sig->sig_class == 0x30)
1085     {
1086       if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
1087           || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1088         {
1089           return check_key_signature (c->ctrl, c->list, node, is_selfsig);
1090         }
1091       else if (sig->sig_class == 0x20)
1092         {
1093           log_error (_("standalone revocation - "
1094                        "use \"gpg --import\" to apply\n"));
1095           return GPG_ERR_NOT_PROCESSED;
1096         }
1097       else
1098         {
1099           log_error ("invalid root packet for sigclass %02x\n", sig->sig_class);
1100           return GPG_ERR_SIG_CLASS;
1101         }
1102     }
1103   else
1104     return GPG_ERR_SIG_CLASS;
1105
1106   /* We only get here if we are checking the signature of a binary
1107      (0x00) or text document (0x01).  */
1108   rc = check_signature2 (c->ctrl, sig, md, NULL, is_expkey, is_revkey, r_pk);
1109   if (! rc)
1110     md_good = md;
1111   else if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE && md2)
1112     {
1113       PKT_public_key *pk2;
1114
1115       rc = check_signature2 (c->ctrl, sig, md2, NULL, is_expkey, is_revkey,
1116                              r_pk? &pk2 : NULL);
1117       if (!rc)
1118         {
1119           md_good = md2;
1120           if (r_pk)
1121             {
1122               free_public_key (*r_pk);
1123               *r_pk = pk2;
1124             }
1125         }
1126     }
1127
1128   if (md_good)
1129     {
1130       unsigned char *buffer = gcry_md_read (md_good, sig->digest_algo);
1131       sig->digest_len = gcry_md_get_algo_dlen (map_md_openpgp_to_gcry (algo));
1132       memcpy (sig->digest, buffer, sig->digest_len);
1133     }
1134
1135   gcry_md_close (md);
1136   gcry_md_close (md2);
1137
1138   return rc;
1139 }
1140
1141
1142 static void
1143 print_userid (PACKET *pkt)
1144 {
1145   if (!pkt)
1146     BUG();
1147
1148   if (pkt->pkttype != PKT_USER_ID)
1149     {
1150       es_printf ("ERROR: unexpected packet type %d", pkt->pkttype );
1151       return;
1152     }
1153   if (opt.with_colons)
1154     {
1155       if (pkt->pkt.user_id->attrib_data)
1156         es_printf("%u %lu",
1157                   pkt->pkt.user_id->numattribs,
1158                   pkt->pkt.user_id->attrib_len);
1159       else
1160         es_write_sanitized (es_stdout, pkt->pkt.user_id->name,
1161                             pkt->pkt.user_id->len, ":", NULL);
1162     }
1163   else
1164     print_utf8_buffer (es_stdout, pkt->pkt.user_id->name,
1165                        pkt->pkt.user_id->len );
1166 }
1167
1168
1169 /*
1170  * List the keyblock in a user friendly way
1171  */
1172 static void
1173 list_node (CTX c, kbnode_t node)
1174 {
1175   if (!node)
1176     ;
1177   else if (node->pkt->pkttype == PKT_PUBLIC_KEY
1178            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1179     {
1180       PKT_public_key *pk = node->pkt->pkt.public_key;
1181
1182       if (opt.with_colons)
1183         {
1184           u32 keyid[2];
1185
1186           keyid_from_pk( pk, keyid );
1187           if (pk->flags.primary)
1188             c->trustletter = (opt.fast_list_mode
1189                               ? 0
1190                               : get_validity_info
1191                                   (c->ctrl,
1192                                    node->pkt->pkttype == PKT_PUBLIC_KEY
1193                                    ? node : NULL,
1194                                    pk, NULL));
1195           es_printf ("%s:", pk->flags.primary? "pub":"sub" );
1196           if (c->trustletter)
1197             es_putc (c->trustletter, es_stdout);
1198           es_printf (":%u:%d:%08lX%08lX:%s:%s::",
1199                      nbits_from_pk( pk ),
1200                      pk->pubkey_algo,
1201                      (ulong)keyid[0],(ulong)keyid[1],
1202                      colon_datestr_from_pk( pk ),
1203                      colon_strtime (pk->expiredate) );
1204           if (pk->flags.primary && !opt.fast_list_mode)
1205             es_putc (get_ownertrust_info (c->ctrl, pk, 1), es_stdout);
1206           es_putc (':', es_stdout);
1207           es_putc ('\n', es_stdout);
1208         }
1209       else
1210         {
1211           print_key_line (c->ctrl, es_stdout, pk, 0);
1212         }
1213
1214       if (opt.keyid_format == KF_NONE && !opt.with_colons)
1215         ; /* Already printed.  */
1216       else if ((pk->flags.primary && opt.fingerprint) || opt.fingerprint > 1)
1217         print_fingerprint (c->ctrl, NULL, pk, 0);
1218
1219       if (pk->flags.primary)
1220         {
1221           int kl = opt.keyid_format == KF_NONE? 0 : keystrlen ();
1222
1223           /* Now list all userids with their signatures. */
1224           for (node = node->next; node; node = node->next)
1225             {
1226               if (node->pkt->pkttype == PKT_SIGNATURE)
1227                 {
1228                   list_node (c,  node );
1229                 }
1230               else if (node->pkt->pkttype == PKT_USER_ID)
1231                 {
1232                   if (opt.with_colons)
1233                     es_printf ("%s:::::::::",
1234                                node->pkt->pkt.user_id->attrib_data?"uat":"uid");
1235                   else
1236                     es_printf ("uid%*s",
1237                                kl + (opt.legacy_list_mode? 9:11),
1238                                "" );
1239                   print_userid (node->pkt);
1240                   if (opt.with_colons)
1241                     es_putc (':', es_stdout);
1242                   es_putc ('\n', es_stdout);
1243                 }
1244               else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1245                 {
1246                   list_node(c,  node );
1247                 }
1248             }
1249         }
1250     }
1251   else if (node->pkt->pkttype == PKT_SECRET_KEY
1252            || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1253     {
1254
1255       log_debug ("FIXME: No way to print secret key packets here\n");
1256       /* fixme: We may use a function to turn a secret key packet into
1257          a public key one and use that here.  */
1258     }
1259   else if (node->pkt->pkttype == PKT_SIGNATURE)
1260     {
1261       PKT_signature *sig = node->pkt->pkt.signature;
1262       int is_selfsig = 0;
1263       int rc2 = 0;
1264       size_t n;
1265       char *p;
1266       int sigrc = ' ';
1267
1268       if (!opt.verbose)
1269         return;
1270
1271       if (sig->sig_class == 0x20 || sig->sig_class == 0x30)
1272         es_fputs ("rev", es_stdout);
1273       else
1274         es_fputs ("sig", es_stdout);
1275       if (opt.check_sigs)
1276         {
1277           fflush (stdout);
1278           rc2 = do_check_sig (c, node, &is_selfsig, NULL, NULL, NULL);
1279           switch (gpg_err_code (rc2))
1280             {
1281             case 0:                       sigrc = '!'; break;
1282             case GPG_ERR_BAD_SIGNATURE:   sigrc = '-'; break;
1283             case GPG_ERR_NO_PUBKEY:
1284             case GPG_ERR_UNUSABLE_PUBKEY: sigrc = '?'; break;
1285             default:                      sigrc = '%'; break;
1286             }
1287         }
1288       else /* Check whether this is a self signature.  */
1289         {
1290           u32 keyid[2];
1291
1292           if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
1293               || c->list->pkt->pkttype == PKT_SECRET_KEY )
1294             {
1295               keyid_from_pk (c->list->pkt->pkt.public_key, keyid);
1296
1297               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
1298                 is_selfsig = 1;
1299             }
1300         }
1301
1302       if (opt.with_colons)
1303         {
1304           es_putc (':', es_stdout);
1305           if (sigrc != ' ')
1306             es_putc (sigrc, es_stdout);
1307           es_printf ("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1308                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1309                      colon_datestr_from_sig (sig),
1310                      colon_expirestr_from_sig (sig));
1311
1312           if (sig->trust_depth || sig->trust_value)
1313             es_printf ("%d %d",sig->trust_depth,sig->trust_value);
1314           es_putc (':', es_stdout);
1315
1316           if (sig->trust_regexp)
1317             es_write_sanitized (es_stdout, sig->trust_regexp,
1318                                 strlen (sig->trust_regexp), ":", NULL);
1319           es_putc (':', es_stdout);
1320         }
1321       else
1322         es_printf ("%c       %s %s   ",
1323                    sigrc, keystr (sig->keyid), datestr_from_sig(sig));
1324       if (sigrc == '%')
1325         es_printf ("[%s] ", gpg_strerror (rc2) );
1326       else if (sigrc == '?')
1327         ;
1328       else if (is_selfsig)
1329         {
1330           if (opt.with_colons)
1331             es_putc (':', es_stdout);
1332           es_fputs (sig->sig_class == 0x18? "[keybind]":"[selfsig]", es_stdout);
1333           if (opt.with_colons)
1334             es_putc (':', es_stdout);
1335         }
1336       else if (!opt.fast_list_mode)
1337         {
1338           p = get_user_id (c->ctrl, sig->keyid, &n, NULL);
1339           es_write_sanitized (es_stdout, p, n,
1340                               opt.with_colons?":":NULL, NULL );
1341           xfree (p);
1342         }
1343       if (opt.with_colons)
1344         es_printf (":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1345       es_putc ('\n', es_stdout);
1346     }
1347   else
1348     log_error ("invalid node with packet of type %d\n", node->pkt->pkttype);
1349 }
1350
1351
1352 int
1353 proc_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1354 {
1355   int rc;
1356   CTX c = xmalloc_clear (sizeof *c);
1357
1358   c->ctrl = ctrl;
1359   c->anchor = anchor;
1360   rc = do_proc_packets (c, a);
1361   xfree (c);
1362
1363   return rc;
1364 }
1365
1366
1367 int
1368 proc_signature_packets (ctrl_t ctrl, void *anchor, iobuf_t a,
1369                         strlist_t signedfiles, const char *sigfilename )
1370 {
1371   CTX c = xmalloc_clear (sizeof *c);
1372   int rc;
1373
1374   c->ctrl = ctrl;
1375   c->anchor = anchor;
1376   c->sigs_only = 1;
1377
1378   c->signed_data.data_fd = -1;
1379   c->signed_data.data_names = signedfiles;
1380   c->signed_data.used = !!signedfiles;
1381
1382   c->sigfilename = sigfilename;
1383   rc = do_proc_packets (c, a);
1384
1385   /* If we have not encountered any signature we print an error
1386      messages, send a NODATA status back and return an error code.
1387      Using log_error is required because verify_files does not check
1388      error codes for each file but we want to terminate the process
1389      with an error. */
1390   if (!rc && !c->any.sig_seen)
1391     {
1392       write_status_text (STATUS_NODATA, "4");
1393       log_error (_("no signature found\n"));
1394       rc = GPG_ERR_NO_DATA;
1395     }
1396
1397   /* Propagate the signature seen flag upward. Do this only on success
1398      so that we won't issue the nodata status several times.  */
1399   if (!rc && c->anchor && c->any.sig_seen)
1400     c->anchor->any.sig_seen = 1;
1401
1402   xfree (c);
1403   return rc;
1404 }
1405
1406
1407 int
1408 proc_signature_packets_by_fd (ctrl_t ctrl,
1409                               void *anchor, iobuf_t a, int signed_data_fd )
1410 {
1411   int rc;
1412   CTX c;
1413
1414   c = xtrycalloc (1, sizeof *c);
1415   if (!c)
1416     return gpg_error_from_syserror ();
1417
1418   c->ctrl = ctrl;
1419   c->anchor = anchor;
1420   c->sigs_only = 1;
1421
1422   c->signed_data.data_fd = signed_data_fd;
1423   c->signed_data.data_names = NULL;
1424   c->signed_data.used = (signed_data_fd != -1);
1425
1426   rc = do_proc_packets (c, a);
1427
1428   /* If we have not encountered any signature we print an error
1429      messages, send a NODATA status back and return an error code.
1430      Using log_error is required because verify_files does not check
1431      error codes for each file but we want to terminate the process
1432      with an error. */
1433   if (!rc && !c->any.sig_seen)
1434     {
1435       write_status_text (STATUS_NODATA, "4");
1436       log_error (_("no signature found\n"));
1437       rc = gpg_error (GPG_ERR_NO_DATA);
1438     }
1439
1440   /* Propagate the signature seen flag upward. Do this only on success
1441      so that we won't issue the nodata status several times. */
1442   if (!rc && c->anchor && c->any.sig_seen)
1443     c->anchor->any.sig_seen = 1;
1444
1445   xfree ( c );
1446   return rc;
1447 }
1448
1449
1450 int
1451 proc_encryption_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1452 {
1453   CTX c = xmalloc_clear (sizeof *c);
1454   int rc;
1455
1456   c->ctrl = ctrl;
1457   c->anchor = anchor;
1458   c->encrypt_only = 1;
1459   rc = do_proc_packets (c, a);
1460   xfree (c);
1461   return rc;
1462 }
1463
1464
1465 static int
1466 check_nesting (CTX c)
1467 {
1468   int level;
1469
1470   for (level=0; c; c = c->anchor)
1471     level++;
1472
1473   if (level > MAX_NESTING_DEPTH)
1474     {
1475       log_error ("input data with too deeply nested packets\n");
1476       write_status_text (STATUS_UNEXPECTED, "1");
1477       return GPG_ERR_BAD_DATA;
1478     }
1479
1480   return 0;
1481 }
1482
1483
1484 static int
1485 do_proc_packets (CTX c, iobuf_t a)
1486 {
1487   PACKET *pkt;
1488   struct parse_packet_ctx_s parsectx;
1489   int rc = 0;
1490   int any_data = 0;
1491   int newpkt;
1492
1493   rc = check_nesting (c);
1494   if (rc)
1495     return rc;
1496
1497   pkt = xmalloc( sizeof *pkt );
1498   c->iobuf = a;
1499   init_packet(pkt);
1500   init_parse_packet (&parsectx, a);
1501   while ((rc=parse_packet (&parsectx, pkt)) != -1)
1502     {
1503       any_data = 1;
1504       if (rc)
1505         {
1506           free_packet (pkt, &parsectx);
1507           /* Stop processing when an invalid packet has been encountered
1508            * but don't do so when we are doing a --list-packets.  */
1509           if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
1510               && opt.list_packets == 0)
1511             break;
1512           continue;
1513         }
1514       newpkt = -1;
1515       if (opt.list_packets)
1516         {
1517           switch (pkt->pkttype)
1518             {
1519             case PKT_PUBKEY_ENC:    proc_pubkey_enc (c, pkt); break;
1520             case PKT_SYMKEY_ENC:    proc_symkey_enc (c, pkt); break;
1521             case PKT_ENCRYPTED:
1522             case PKT_ENCRYPTED_MDC:
1523             case PKT_ENCRYPTED_AEAD:proc_encrypted (c, pkt); break;
1524             case PKT_COMPRESSED:    rc = proc_compressed (c, pkt); break;
1525             default: newpkt = 0; break;
1526             }
1527         }
1528       else if (c->sigs_only)
1529         {
1530           switch (pkt->pkttype)
1531             {
1532             case PKT_PUBLIC_KEY:
1533             case PKT_SECRET_KEY:
1534             case PKT_USER_ID:
1535             case PKT_SYMKEY_ENC:
1536             case PKT_PUBKEY_ENC:
1537             case PKT_ENCRYPTED:
1538             case PKT_ENCRYPTED_MDC:
1539             case PKT_ENCRYPTED_AEAD:
1540               write_status_text( STATUS_UNEXPECTED, "0" );
1541               rc = GPG_ERR_UNEXPECTED;
1542               goto leave;
1543
1544             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1545             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1546             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1547             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1548             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1549             default: newpkt = 0; break;
1550             }
1551         }
1552       else if (c->encrypt_only)
1553         {
1554           switch (pkt->pkttype)
1555             {
1556             case PKT_PUBLIC_KEY:
1557             case PKT_SECRET_KEY:
1558             case PKT_USER_ID:
1559               write_status_text (STATUS_UNEXPECTED, "0");
1560               rc = GPG_ERR_UNEXPECTED;
1561               goto leave;
1562
1563             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1564             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1565             case PKT_PUBKEY_ENC:  proc_pubkey_enc (c, pkt); break;
1566             case PKT_ENCRYPTED:
1567             case PKT_ENCRYPTED_MDC:
1568             case PKT_ENCRYPTED_AEAD: proc_encrypted (c, pkt); break;
1569             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1570             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1571             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1572             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1573             default: newpkt = 0; break;
1574             }
1575         }
1576       else
1577         {
1578           switch (pkt->pkttype)
1579             {
1580             case PKT_PUBLIC_KEY:
1581             case PKT_SECRET_KEY:
1582               release_list (c);
1583               c->list = new_kbnode (pkt);
1584               newpkt = 1;
1585               break;
1586             case PKT_PUBLIC_SUBKEY:
1587             case PKT_SECRET_SUBKEY:
1588               newpkt = add_subkey (c, pkt);
1589               break;
1590             case PKT_USER_ID:     newpkt = add_user_id (c, pkt); break;
1591             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1592             case PKT_PUBKEY_ENC:  proc_pubkey_enc (c, pkt); break;
1593             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1594             case PKT_ENCRYPTED:
1595             case PKT_ENCRYPTED_MDC:
1596             case PKT_ENCRYPTED_AEAD: proc_encrypted (c, pkt); break;
1597             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1598             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1599             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1600             case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1601             case PKT_RING_TRUST:  newpkt = add_ring_trust (c, pkt); break;
1602             default: newpkt = 0; break;
1603             }
1604         }
1605
1606       if (rc)
1607         goto leave;
1608
1609       /* This is a very ugly construct and frankly, I don't remember why
1610        * I used it.  Adding the MDC check here is a hack.
1611        * The right solution is to initiate another context for encrypted
1612        * packet and not to reuse the current one ...  It works right
1613        * when there is a compression packet between which adds just
1614        * an extra layer.
1615        * Hmmm: Rewrite this whole module here??
1616        */
1617       if (pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC)
1618         c->any.data = (pkt->pkttype == PKT_PLAINTEXT);
1619
1620       if (newpkt == -1)
1621         ;
1622       else if (newpkt)
1623         {
1624           pkt = xmalloc (sizeof *pkt);
1625           init_packet (pkt);
1626         }
1627       else
1628         free_packet (pkt, &parsectx);
1629     }
1630
1631   if (rc == GPG_ERR_INV_PACKET)
1632     write_status_text (STATUS_NODATA, "3");
1633
1634   if (any_data)
1635     rc = 0;
1636   else if (rc == -1)
1637     write_status_text (STATUS_NODATA, "2");
1638
1639
1640  leave:
1641   release_list (c);
1642   xfree(c->dek);
1643   free_packet (pkt, &parsectx);
1644   deinit_parse_packet (&parsectx);
1645   xfree (pkt);
1646   free_md_filter_context (&c->mfx);
1647   return rc;
1648 }
1649
1650
1651 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1652    of the notation data. */
1653 static pka_info_t *
1654 get_pka_address (PKT_signature *sig)
1655 {
1656   pka_info_t *pka = NULL;
1657   struct notation *nd,*notation;
1658
1659   notation=sig_to_notation(sig);
1660
1661   for(nd=notation;nd;nd=nd->next)
1662     {
1663       if(strcmp(nd->name,"pka-address@gnupg.org")!=0)
1664         continue; /* Not the notation we want. */
1665
1666       /* For now we only use the first valid PKA notation. In future
1667          we might want to keep additional PKA notations in a linked
1668          list. */
1669       if (is_valid_mailbox (nd->value))
1670         {
1671           pka = xmalloc (sizeof *pka + strlen(nd->value));
1672           pka->valid = 0;
1673           pka->checked = 0;
1674           pka->uri = NULL;
1675           strcpy (pka->email, nd->value);
1676           break;
1677         }
1678     }
1679
1680   free_notation(notation);
1681
1682   return pka;
1683 }
1684
1685
1686 /* Return the URI from a DNS PKA record.  If this record has already
1687    be retrieved for the signature we merely return it; if not we go
1688    out and try to get that DNS record. */
1689 static const char *
1690 pka_uri_from_sig (CTX c, PKT_signature *sig)
1691 {
1692   if (!sig->flags.pka_tried)
1693     {
1694       log_assert (!sig->pka_info);
1695       sig->flags.pka_tried = 1;
1696       sig->pka_info = get_pka_address (sig);
1697       if (sig->pka_info)
1698         {
1699           char *url;
1700           unsigned char *fpr;
1701           size_t fprlen;
1702
1703           if (!gpg_dirmngr_get_pka (c->ctrl, sig->pka_info->email,
1704                                     &fpr, &fprlen, &url))
1705             {
1706               if (fpr && fprlen == sizeof sig->pka_info->fpr)
1707                 {
1708                   memcpy (sig->pka_info->fpr, fpr, fprlen);
1709                   if (url)
1710                     {
1711                       sig->pka_info->valid = 1;
1712                       if (!*url)
1713                         xfree (url);
1714                       else
1715                         sig->pka_info->uri = url;
1716                       url = NULL;
1717                     }
1718                 }
1719               xfree (fpr);
1720               xfree (url);
1721             }
1722         }
1723     }
1724   return sig->pka_info? sig->pka_info->uri : NULL;
1725 }
1726
1727
1728 /* Return true if the AKL has the WKD method specified.  */
1729 static int
1730 akl_has_wkd_method (void)
1731 {
1732   struct akl *akl;
1733
1734   for (akl = opt.auto_key_locate; akl; akl = akl->next)
1735     if (akl->type == AKL_WKD)
1736       return 1;
1737   return 0;
1738 }
1739
1740
1741 /* Return the ISSUER fingerprint buffer and its lenbgth at R_LEN.
1742  * Returns NULL if not available.  The returned buffer is valid as
1743  * long as SIG is not modified.  */
1744 const byte *
1745 issuer_fpr_raw (PKT_signature *sig, size_t *r_len)
1746 {
1747   const byte *p;
1748   size_t n;
1749
1750   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_ISSUER_FPR, &n);
1751   if (p && n == 21 && p[0] == 4)
1752     {
1753       *r_len = n - 1;
1754       return p+1;
1755     }
1756   *r_len = 0;
1757   return NULL;
1758 }
1759
1760
1761 /* Return the ISSUER fingerprint string in human readable format if
1762  * available.  Caller must release the string.  */
1763 /* FIXME: Move to another file.  */
1764 char *
1765 issuer_fpr_string (PKT_signature *sig)
1766 {
1767   const byte *p;
1768   size_t n;
1769
1770   p = issuer_fpr_raw (sig, &n);
1771   return p? bin2hex (p, n, NULL) : NULL;
1772 }
1773
1774
1775 static void
1776 print_good_bad_signature (int statno, const char *keyid_str, kbnode_t un,
1777                           PKT_signature *sig, int rc)
1778 {
1779   char *p;
1780
1781   write_status_text_and_buffer (statno, keyid_str,
1782                                 un? un->pkt->pkt.user_id->name:"[?]",
1783                                 un? un->pkt->pkt.user_id->len:3,
1784                                 -1);
1785
1786   if (un)
1787     p = utf8_to_native (un->pkt->pkt.user_id->name,
1788                         un->pkt->pkt.user_id->len, 0);
1789   else
1790     p = xstrdup ("[?]");
1791
1792   if (rc)
1793     log_info (_("BAD signature from \"%s\""), p);
1794   else if (sig->flags.expired)
1795     log_info (_("Expired signature from \"%s\""), p);
1796   else
1797     log_info (_("Good signature from \"%s\""), p);
1798
1799   xfree (p);
1800 }
1801
1802
1803 static int
1804 check_sig_and_print (CTX c, kbnode_t node)
1805 {
1806   PKT_signature *sig = node->pkt->pkt.signature;
1807   const char *astr;
1808   int rc;
1809   int is_expkey = 0;
1810   int is_revkey = 0;
1811   char *issuer_fpr = NULL;
1812   PKT_public_key *pk = NULL;  /* The public key for the signature or NULL. */
1813   int tried_ks_by_fpr;
1814
1815   if (opt.skip_verify)
1816     {
1817       log_info(_("signature verification suppressed\n"));
1818       return 0;
1819     }
1820
1821   /* Check that the message composition is valid.
1822    *
1823    * Per RFC-2440bis (-15) allowed:
1824    *
1825    * S{1,n}           -- detached signature.
1826    * S{1,n} P         -- old style PGP2 signature
1827    * O{1,n} P S{1,n}  -- standard OpenPGP signature.
1828    * C P S{1,n}       -- cleartext signature.
1829    *
1830    *
1831    *      O = One-Pass Signature packet.
1832    *      S = Signature packet.
1833    *      P = OpenPGP Message packet (Encrypted | Compressed | Literal)
1834    *             (Note that the current rfc2440bis draft also allows
1835    *              for a signed message but that does not work as it
1836    *              introduces ambiguities.)
1837    *          We keep track of these packages using the marker packet
1838    *          CTRLPKT_PLAINTEXT_MARK.
1839    *      C = Marker packet for cleartext signatures.
1840    *
1841    * We reject all other messages.
1842    *
1843    * Actually we are calling this too often, i.e. for verification of
1844    * each message but better have some duplicate work than to silently
1845    * introduce a bug here.
1846    */
1847   {
1848     kbnode_t n;
1849     int n_onepass, n_sig;
1850
1851 /*     log_debug ("checking signature packet composition\n"); */
1852 /*     dump_kbnode (c->list); */
1853
1854     n = c->list;
1855     log_assert (n);
1856     if ( n->pkt->pkttype == PKT_SIGNATURE )
1857       {
1858         /* This is either "S{1,n}" case (detached signature) or
1859            "S{1,n} P" (old style PGP2 signature). */
1860         for (n = n->next; n; n = n->next)
1861           if (n->pkt->pkttype != PKT_SIGNATURE)
1862             break;
1863         if (!n)
1864           ; /* Okay, this is a detached signature.  */
1865         else if (n->pkt->pkttype == PKT_GPG_CONTROL
1866                  && (n->pkt->pkt.gpg_control->control
1867                      == CTRLPKT_PLAINTEXT_MARK) )
1868           {
1869             if (n->next)
1870               goto ambiguous;  /* We only allow one P packet. */
1871           }
1872         else
1873           goto ambiguous;
1874       }
1875     else if (n->pkt->pkttype == PKT_ONEPASS_SIG)
1876       {
1877         /* This is the "O{1,n} P S{1,n}" case (standard signature). */
1878         for (n_onepass=1, n = n->next;
1879              n && n->pkt->pkttype == PKT_ONEPASS_SIG; n = n->next)
1880           n_onepass++;
1881         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1882                     && (n->pkt->pkt.gpg_control->control
1883                         == CTRLPKT_PLAINTEXT_MARK)))
1884           goto ambiguous;
1885         for (n_sig=0, n = n->next;
1886              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1887           n_sig++;
1888         if (!n_sig)
1889           goto ambiguous;
1890
1891         /* If we wanted to disallow multiple sig verification, we'd do
1892          * something like this:
1893          *
1894          * if (n)
1895          *   goto ambiguous;
1896          *
1897          * However, this can stay allowable as we can't get here.  */
1898
1899         if (n_onepass != n_sig)
1900           {
1901             log_info ("number of one-pass packets does not match "
1902                       "number of signature packets\n");
1903             goto ambiguous;
1904           }
1905       }
1906     else if (n->pkt->pkttype == PKT_GPG_CONTROL
1907              && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
1908       {
1909         /* This is the "C P S{1,n}" case (clear text signature). */
1910         n = n->next;
1911         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1912                     && (n->pkt->pkt.gpg_control->control
1913                         == CTRLPKT_PLAINTEXT_MARK)))
1914           goto ambiguous;
1915         for (n_sig=0, n = n->next;
1916              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1917           n_sig++;
1918         if (n || !n_sig)
1919           goto ambiguous;
1920       }
1921     else
1922       {
1923       ambiguous:
1924         log_error(_("can't handle this ambiguous signature data\n"));
1925         return 0;
1926       }
1927   }
1928
1929   if (sig->signers_uid)
1930     write_status_buffer (STATUS_NEWSIG,
1931                          sig->signers_uid, strlen (sig->signers_uid), 0);
1932   else
1933     write_status_text (STATUS_NEWSIG, NULL);
1934
1935   astr = openpgp_pk_algo_name ( sig->pubkey_algo );
1936   issuer_fpr = issuer_fpr_string (sig);
1937
1938   if (issuer_fpr)
1939     {
1940       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1941       log_info (_("               using %s key %s\n"),
1942                 astr? astr: "?", issuer_fpr);
1943
1944     }
1945   else if (!keystrlen () || keystrlen () > 8)
1946     {
1947       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1948       log_info (_("               using %s key %s\n"),
1949                 astr? astr: "?", keystr(sig->keyid));
1950     }
1951   else /* Legacy format.  */
1952     log_info (_("Signature made %s using %s key ID %s\n"),
1953               asctimestamp(sig->timestamp), astr? astr: "?",
1954               keystr(sig->keyid));
1955
1956   /* In verbose mode print the signers UID.  */
1957   if (sig->signers_uid)
1958     log_info (_("               issuer \"%s\"\n"), sig->signers_uid);
1959
1960   rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
1961
1962   /* If the key isn't found, check for a preferred keyserver.  */
1963   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY && sig->flags.pref_ks)
1964     {
1965       const byte *p;
1966       int seq = 0;
1967       size_t n;
1968
1969       while ((p=enum_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1970         {
1971           /* According to my favorite copy editor, in English grammar,
1972              you say "at" if the key is located on a web page, but
1973              "from" if it is located on a keyserver.  I'm not going to
1974              even try to make two strings here :) */
1975           log_info(_("Key available at: ") );
1976           print_utf8_buffer (log_get_stream(), p, n);
1977           log_printf ("\n");
1978
1979           if (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1980               && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1981             {
1982               struct keyserver_spec *spec;
1983
1984               spec = parse_preferred_keyserver (sig);
1985               if (spec)
1986                 {
1987                   int res;
1988
1989                   free_public_key (pk);
1990                   pk = NULL;
1991                   glo_ctrl.in_auto_key_retrieve++;
1992                   res = keyserver_import_keyid (c->ctrl, sig->keyid,spec, 1);
1993                   glo_ctrl.in_auto_key_retrieve--;
1994                   if (!res)
1995                     rc = do_check_sig (c, node, NULL,
1996                                        &is_expkey, &is_revkey, &pk);
1997                   free_keyserver_spec (spec);
1998
1999                   if (!rc)
2000                     break;
2001                 }
2002             }
2003         }
2004     }
2005
2006   /* If the avove methods didn't work, our next try is to use the URI
2007    * from a DNS PKA record.  */
2008   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2009       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
2010       && (opt.keyserver_options.options & KEYSERVER_HONOR_PKA_RECORD))
2011     {
2012       const char *uri = pka_uri_from_sig (c, sig);
2013
2014       if (uri)
2015         {
2016           /* FIXME: We might want to locate the key using the
2017              fingerprint instead of the keyid. */
2018           int res;
2019           struct keyserver_spec *spec;
2020
2021           spec = parse_keyserver_uri (uri, 1);
2022           if (spec)
2023             {
2024               free_public_key (pk);
2025               pk = NULL;
2026               glo_ctrl.in_auto_key_retrieve++;
2027               res = keyserver_import_keyid (c->ctrl, sig->keyid, spec, 1);
2028               glo_ctrl.in_auto_key_retrieve--;
2029               free_keyserver_spec (spec);
2030               if (!res)
2031                 rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
2032             }
2033         }
2034     }
2035
2036   /* If the above methods didn't work, our next try is to locate
2037    * the key via its fingerprint from a keyserver.  This requires
2038    * that the signers fingerprint is encoded in the signature.  We
2039    * favor this over the WKD method (to be tried next), because an
2040    * arbitrary keyserver is less subject to web bug like monitoring.  */
2041   tried_ks_by_fpr = 0;
2042   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2043       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
2044       && keyserver_any_configured (c->ctrl))
2045     {
2046       int res;
2047       const byte *p;
2048       size_t n;
2049
2050       p = issuer_fpr_raw (sig, &n);
2051       if (p)
2052         {
2053           /* v4 packet with a SHA-1 fingerprint.  */
2054           free_public_key (pk);
2055           pk = NULL;
2056           glo_ctrl.in_auto_key_retrieve++;
2057           res = keyserver_import_fprint (c->ctrl, p, n, opt.keyserver, 1);
2058           tried_ks_by_fpr = 1;
2059           glo_ctrl.in_auto_key_retrieve--;
2060           if (!res)
2061             rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
2062         }
2063     }
2064
2065   /* If the above methods didn't work, our next try is to retrieve the
2066    * key from the WKD. */
2067   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2068       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
2069       && !opt.flags.disable_signer_uid
2070       && akl_has_wkd_method ()
2071       && sig->signers_uid)
2072     {
2073       int res;
2074
2075       free_public_key (pk);
2076       pk = NULL;
2077       glo_ctrl.in_auto_key_retrieve++;
2078       res = keyserver_import_wkd (c->ctrl, sig->signers_uid, 1, NULL, NULL);
2079       glo_ctrl.in_auto_key_retrieve--;
2080       /* Fixme: If the fingerprint is embedded in the signature,
2081        * compare it to the fingerprint of the returned key.  */
2082       if (!res)
2083         rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
2084     }
2085
2086   /* If the above methods did't work, our next try is to use a
2087    * keyserver.  */
2088   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2089       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
2090       && !tried_ks_by_fpr
2091       && keyserver_any_configured (c->ctrl))
2092     {
2093       int res;
2094
2095       free_public_key (pk);
2096       pk = NULL;
2097       glo_ctrl.in_auto_key_retrieve++;
2098       res = keyserver_import_keyid (c->ctrl, sig->keyid, opt.keyserver, 1);
2099       glo_ctrl.in_auto_key_retrieve--;
2100       if (!res)
2101         rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
2102     }
2103
2104   if (!rc || gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
2105     {
2106       kbnode_t un, keyblock;
2107       int count = 0;
2108       int statno;
2109       char keyid_str[50];
2110       PKT_public_key *mainpk = NULL;
2111
2112       if (rc)
2113         statno = STATUS_BADSIG;
2114       else if (sig->flags.expired)
2115         statno = STATUS_EXPSIG;
2116       else if (is_expkey)
2117         statno = STATUS_EXPKEYSIG;
2118       else if(is_revkey)
2119         statno = STATUS_REVKEYSIG;
2120       else
2121         statno = STATUS_GOODSIG;
2122
2123       /* FIXME: We should have the public key in PK and thus the
2124        * keyblock has already been fetched.  Thus we could use the
2125        * fingerprint or PK itself to lookup the entire keyblock.  That
2126        * would best be done with a cache.  */
2127       keyblock = get_pubkeyblock_for_sig (c->ctrl, sig);
2128
2129       snprintf (keyid_str, sizeof keyid_str, "%08lX%08lX [uncertain] ",
2130                 (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
2131
2132       /* Find and print the primary user ID along with the
2133          "Good|Expired|Bad signature" line.  */
2134       for (un=keyblock; un; un = un->next)
2135         {
2136           int valid;
2137
2138           if (un->pkt->pkttype==PKT_PUBLIC_KEY)
2139             {
2140               mainpk = un->pkt->pkt.public_key;
2141               continue;
2142             }
2143           if (un->pkt->pkttype != PKT_USER_ID)
2144             continue;
2145           if (!un->pkt->pkt.user_id->created)
2146             continue;
2147           if (un->pkt->pkt.user_id->flags.revoked)
2148             continue;
2149           if (un->pkt->pkt.user_id->flags.expired)
2150             continue;
2151           if (!un->pkt->pkt.user_id->flags.primary)
2152             continue;
2153           /* We want the textual primary user ID here */
2154           if (un->pkt->pkt.user_id->attrib_data)
2155             continue;
2156
2157           log_assert (mainpk);
2158
2159           /* Since this is just informational, don't actually ask the
2160              user to update any trust information.  (Note: we register
2161              the signature later.)  Because print_good_bad_signature
2162              does not print a LF we need to compute the validity
2163              before calling that function.  */
2164           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2165             valid = get_validity (c->ctrl, keyblock, mainpk,
2166                                   un->pkt->pkt.user_id, NULL, 0);
2167           else
2168             valid = 0; /* Not used.  */
2169
2170           keyid_str[17] = 0; /* cut off the "[uncertain]" part */
2171
2172           print_good_bad_signature (statno, keyid_str, un, sig, rc);
2173
2174           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2175             log_printf (" [%s]\n",trust_value_to_string(valid));
2176           else
2177             log_printf ("\n");
2178
2179           count++;
2180         }
2181
2182       log_assert (mainpk);
2183
2184       /* In case we did not found a valid textual userid above
2185          we print the first user id packet or a "[?]" instead along
2186          with the "Good|Expired|Bad signature" line.  */
2187       if (!count)
2188         {
2189           /* Try for an invalid textual userid */
2190           for (un=keyblock; un; un = un->next)
2191             {
2192               if (un->pkt->pkttype == PKT_USER_ID
2193                   && !un->pkt->pkt.user_id->attrib_data)
2194                 break;
2195             }
2196
2197           /* Try for any userid at all */
2198           if (!un)
2199             {
2200               for (un=keyblock; un; un = un->next)
2201                 {
2202                   if (un->pkt->pkttype == PKT_USER_ID)
2203                     break;
2204                 }
2205             }
2206
2207           if (opt.trust_model==TM_ALWAYS || !un)
2208             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
2209
2210           print_good_bad_signature (statno, keyid_str, un, sig, rc);
2211
2212           if (opt.trust_model != TM_ALWAYS && un)
2213             log_printf (" %s",_("[uncertain]") );
2214           log_printf ("\n");
2215         }
2216
2217       /* If we have a good signature and already printed
2218        * the primary user ID, print all the other user IDs */
2219       if (count
2220           && !rc
2221           && !(opt.verify_options & VERIFY_SHOW_PRIMARY_UID_ONLY))
2222         {
2223           char *p;
2224           for( un=keyblock; un; un = un->next)
2225             {
2226               if (un->pkt->pkttype != PKT_USER_ID)
2227                 continue;
2228               if ((un->pkt->pkt.user_id->flags.revoked
2229                    || un->pkt->pkt.user_id->flags.expired)
2230                   && !(opt.verify_options & VERIFY_SHOW_UNUSABLE_UIDS))
2231                 continue;
2232               /* Skip textual primary user ids which we printed above. */
2233               if (un->pkt->pkt.user_id->flags.primary
2234                   && !un->pkt->pkt.user_id->attrib_data )
2235                 continue;
2236
2237               /* If this user id has attribute data, print that.  */
2238               if (un->pkt->pkt.user_id->attrib_data)
2239                 {
2240                   dump_attribs (un->pkt->pkt.user_id, mainpk);
2241
2242                   if (opt.verify_options&VERIFY_SHOW_PHOTOS)
2243                     show_photos (c->ctrl,
2244                                  un->pkt->pkt.user_id->attribs,
2245                                  un->pkt->pkt.user_id->numattribs,
2246                                  mainpk ,un->pkt->pkt.user_id);
2247                 }
2248
2249               p = utf8_to_native (un->pkt->pkt.user_id->name,
2250                                   un->pkt->pkt.user_id->len, 0);
2251               log_info (_("                aka \"%s\""), p);
2252               xfree (p);
2253
2254               if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2255                 {
2256                   const char *valid;
2257
2258                   if (un->pkt->pkt.user_id->flags.revoked)
2259                     valid = _("revoked");
2260                   else if (un->pkt->pkt.user_id->flags.expired)
2261                     valid = _("expired");
2262                   else
2263                     /* Since this is just informational, don't
2264                        actually ask the user to update any trust
2265                        information.  */
2266                     valid = (trust_value_to_string
2267                              (get_validity (c->ctrl, keyblock, mainpk,
2268                                             un->pkt->pkt.user_id, NULL, 0)));
2269                   log_printf (" [%s]\n",valid);
2270                 }
2271               else
2272                 log_printf ("\n");
2273             }
2274         }
2275
2276       /* For good signatures print notation data.  */
2277       if (!rc)
2278         {
2279           if ((opt.verify_options & VERIFY_SHOW_POLICY_URLS))
2280             show_policy_url (sig, 0, 1);
2281           else
2282             show_policy_url (sig, 0, 2);
2283
2284           if ((opt.verify_options & VERIFY_SHOW_KEYSERVER_URLS))
2285             show_keyserver_url (sig, 0, 1);
2286           else
2287             show_keyserver_url (sig, 0, 2);
2288
2289           if ((opt.verify_options & VERIFY_SHOW_NOTATIONS))
2290             show_notation
2291               (sig, 0, 1,
2292                (((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)
2293                 + ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0)));
2294           else
2295             show_notation (sig, 0, 2, 0);
2296         }
2297
2298       /* For good signatures print the VALIDSIG status line.  */
2299       if (!rc && is_status_enabled () && pk)
2300         {
2301           char pkhex[MAX_FINGERPRINT_LEN*2+1];
2302           char mainpkhex[MAX_FINGERPRINT_LEN*2+1];
2303
2304           hexfingerprint (pk, pkhex, sizeof pkhex);
2305           hexfingerprint (mainpk, mainpkhex, sizeof mainpkhex);
2306
2307           /* TODO: Replace the reserved '0' in the field below with
2308              bits for status flags (policy url, notation, etc.).  */
2309           write_status_printf (STATUS_VALIDSIG,
2310                                "%s %s %lu %lu %d 0 %d %d %02X %s",
2311                                pkhex,
2312                                strtimestamp (sig->timestamp),
2313                                (ulong)sig->timestamp,
2314                                (ulong)sig->expiredate,
2315                                sig->version, sig->pubkey_algo,
2316                                sig->digest_algo,
2317                                sig->sig_class,
2318                                mainpkhex);
2319         }
2320
2321       /* Print compliance warning for Good signatures.  */
2322       if (!rc && pk && !opt.quiet
2323           && !gnupg_pk_is_compliant (opt.compliance, pk->pubkey_algo,
2324                                      pk->pkey, nbits_from_pk (pk), NULL))
2325         {
2326           log_info (_("WARNING: This key is not suitable for signing"
2327                       " in %s mode\n"),
2328                     gnupg_compliance_option_string (opt.compliance));
2329         }
2330
2331       /* For good signatures compute and print the trust information.
2332          Note that in the Tofu trust model this may ask the user on
2333          how to resolve a conflict.  */
2334       if (!rc)
2335         {
2336           if ((opt.verify_options & VERIFY_PKA_LOOKUPS))
2337             pka_uri_from_sig (c, sig); /* Make sure PKA info is available. */
2338           rc = check_signatures_trust (c->ctrl, sig);
2339         }
2340
2341       /* Print extra information about the signature.  */
2342       if (sig->flags.expired)
2343         {
2344           log_info (_("Signature expired %s\n"), asctimestamp(sig->expiredate));
2345           rc = GPG_ERR_GENERAL; /* Need a better error here?  */
2346         }
2347       else if (sig->expiredate)
2348         log_info (_("Signature expires %s\n"), asctimestamp(sig->expiredate));
2349
2350       if (opt.verbose)
2351         {
2352           char pkstrbuf[PUBKEY_STRING_SIZE];
2353
2354           if (pk)
2355             pubkey_string (pk, pkstrbuf, sizeof pkstrbuf);
2356           else
2357             *pkstrbuf = 0;
2358
2359           log_info (_("%s signature, digest algorithm %s%s%s\n"),
2360                     sig->sig_class==0x00?_("binary"):
2361                     sig->sig_class==0x01?_("textmode"):_("unknown"),
2362                     gcry_md_algo_name (sig->digest_algo),
2363                     *pkstrbuf?_(", key algorithm "):"", pkstrbuf);
2364         }
2365
2366       /* Print final warnings.  */
2367       if (!rc && !c->signed_data.used)
2368         {
2369           /* Signature is basically good but we test whether the
2370              deprecated command
2371                gpg --verify FILE.sig
2372              was used instead of
2373                gpg --verify FILE.sig FILE
2374              to verify a detached signature.  If we figure out that a
2375              data file with a matching name exists, we print a warning.
2376
2377              The problem is that the first form would also verify a
2378              standard signature.  This behavior could be used to
2379              create a made up .sig file for a tarball by creating a
2380              standard signature from a valid detached signature packet
2381              (for example from a signed git tag).  Then replace the
2382              sig file on the FTP server along with a changed tarball.
2383              Using the first form the verify command would correctly
2384              verify the signature but don't even consider the tarball.  */
2385           kbnode_t n;
2386           char *dfile;
2387
2388           dfile = get_matching_datafile (c->sigfilename);
2389           if (dfile)
2390             {
2391               for (n = c->list; n; n = n->next)
2392                 if (n->pkt->pkttype != PKT_SIGNATURE)
2393                   break;
2394               if (n)
2395                 {
2396                   /* Not only signature packets in the tree thus this
2397                      is not a detached signature.  */
2398                   log_info (_("WARNING: not a detached signature; "
2399                               "file '%s' was NOT verified!\n"), dfile);
2400                 }
2401               xfree (dfile);
2402             }
2403         }
2404
2405       /* Compute compliance with CO_DE_VS.  */
2406       if (pk && is_status_enabled ()
2407           && gnupg_pk_is_compliant (CO_DE_VS, pk->pubkey_algo, pk->pkey,
2408                                     nbits_from_pk (pk), NULL)
2409           && gnupg_digest_is_compliant (CO_DE_VS, sig->digest_algo))
2410         write_status_strings (STATUS_VERIFICATION_COMPLIANCE_MODE,
2411                               gnupg_status_compliance_flag (CO_DE_VS),
2412                               NULL);
2413
2414       free_public_key (pk);
2415       pk = NULL;
2416       release_kbnode( keyblock );
2417       if (rc)
2418         g10_errors_seen = 1;
2419       if (opt.batch && rc)
2420         g10_exit (1);
2421     }
2422   else
2423     {
2424       write_status_printf (STATUS_ERRSIG, "%08lX%08lX %d %d %02x %lu %d %s",
2425                            (ulong)sig->keyid[0], (ulong)sig->keyid[1],
2426                            sig->pubkey_algo, sig->digest_algo,
2427                            sig->sig_class, (ulong)sig->timestamp,
2428                            gpg_err_code (rc),
2429                            issuer_fpr? issuer_fpr:"-");
2430       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
2431         {
2432           write_status_printf (STATUS_NO_PUBKEY, "%08lX%08lX",
2433                                (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
2434         }
2435       if (gpg_err_code (rc) != GPG_ERR_NOT_PROCESSED)
2436         log_error (_("Can't check signature: %s\n"), gpg_strerror (rc));
2437     }
2438
2439   free_public_key (pk);
2440   xfree (issuer_fpr);
2441   return rc;
2442 }
2443
2444
2445 /*
2446  * Process the tree which starts at node
2447  */
2448 static void
2449 proc_tree (CTX c, kbnode_t node)
2450 {
2451   kbnode_t n1;
2452   int rc;
2453
2454   if (opt.list_packets || opt.list_only)
2455     return;
2456
2457   /* We must skip our special plaintext marker packets here because
2458      they may be the root packet.  These packets are only used in
2459      additional checks and skipping them here doesn't matter.  */
2460   while (node
2461          && node->pkt->pkttype == PKT_GPG_CONTROL
2462           && node->pkt->pkt.gpg_control->control == CTRLPKT_PLAINTEXT_MARK)
2463     {
2464       node = node->next;
2465     }
2466   if (!node)
2467     return;
2468
2469   c->trustletter = ' ';
2470   if (node->pkt->pkttype == PKT_PUBLIC_KEY
2471       || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2472     {
2473       merge_keys_and_selfsig (c->ctrl, node);
2474       list_node (c, node);
2475     }
2476   else if (node->pkt->pkttype == PKT_SECRET_KEY)
2477     {
2478       merge_keys_and_selfsig (c->ctrl, node);
2479       list_node (c, node);
2480     }
2481   else if (node->pkt->pkttype == PKT_ONEPASS_SIG)
2482     {
2483       /* Check all signatures.  */
2484       if (!c->any.data)
2485         {
2486           int use_textmode = 0;
2487
2488           free_md_filter_context (&c->mfx);
2489           /* Prepare to create all requested message digests.  */
2490           rc = gcry_md_open (&c->mfx.md, 0, 0);
2491           if (rc)
2492             goto hash_err;
2493
2494           /* Fixme: why looking for the signature packet and not the
2495              one-pass packet?  */
2496           for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2497             gcry_md_enable (c->mfx.md, n1->pkt->pkt.signature->digest_algo);
2498
2499           if (n1 && n1->pkt->pkt.onepass_sig->sig_class == 0x01)
2500             use_textmode = 1;
2501
2502           /* Ask for file and hash it. */
2503           if (c->sigs_only)
2504             {
2505               if (c->signed_data.used && c->signed_data.data_fd != -1)
2506                 rc = hash_datafile_by_fd (c->mfx.md, NULL,
2507                                           c->signed_data.data_fd,
2508                                           use_textmode);
2509               else
2510                 rc = hash_datafiles (c->mfx.md, NULL,
2511                                      c->signed_data.data_names,
2512                                      c->sigfilename,
2513                                      use_textmode);
2514             }
2515           else
2516             {
2517               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2518                                               iobuf_get_real_fname (c->iobuf),
2519                                               use_textmode);
2520             }
2521
2522         hash_err:
2523           if (rc)
2524             {
2525               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2526               return;
2527             }
2528         }
2529       else if (c->signed_data.used)
2530         {
2531           log_error (_("not a detached signature\n"));
2532           return;
2533         }
2534
2535       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2536         check_sig_and_print (c, n1);
2537
2538     }
2539   else if (node->pkt->pkttype == PKT_GPG_CONTROL
2540            && node->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
2541     {
2542       /* Clear text signed message.  */
2543       if (!c->any.data)
2544         {
2545           log_error ("cleartext signature without data\n");
2546           return;
2547         }
2548       else if (c->signed_data.used)
2549         {
2550           log_error (_("not a detached signature\n"));
2551           return;
2552         }
2553
2554       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2555         check_sig_and_print (c, n1);
2556
2557     }
2558   else if (node->pkt->pkttype == PKT_SIGNATURE)
2559     {
2560       PKT_signature *sig = node->pkt->pkt.signature;
2561       int multiple_ok = 1;
2562
2563       n1 = find_next_kbnode (node, PKT_SIGNATURE);
2564       if (n1)
2565         {
2566           byte class = sig->sig_class;
2567           byte hash  = sig->digest_algo;
2568
2569           for (; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2570             {
2571               /* We can't currently handle multiple signatures of
2572                * different classes (we'd pretty much have to run a
2573                * different hash context for each), but if they are all
2574                * the same and it is detached signature, we make an
2575                * exception.  Note that the old code also disallowed
2576                * multiple signatures if the digest algorithms are
2577                * different.  We softened this restriction only for
2578                * detached signatures, to be on the safe side. */
2579               if (n1->pkt->pkt.signature->sig_class != class
2580                   || (c->any.data
2581                       && n1->pkt->pkt.signature->digest_algo != hash))
2582                 {
2583                   multiple_ok = 0;
2584                   log_info (_("WARNING: multiple signatures detected.  "
2585                               "Only the first will be checked.\n"));
2586                   break;
2587                 }
2588             }
2589         }
2590
2591       if (sig->sig_class != 0x00 && sig->sig_class != 0x01)
2592         {
2593           log_info(_("standalone signature of class 0x%02x\n"), sig->sig_class);
2594         }
2595       else if (!c->any.data)
2596         {
2597           /* Detached signature */
2598           free_md_filter_context (&c->mfx);
2599           rc = gcry_md_open (&c->mfx.md, sig->digest_algo, 0);
2600           if (rc)
2601             goto detached_hash_err;
2602
2603           if (multiple_ok)
2604             {
2605               /* If we have and want to handle multiple signatures we
2606                * need to enable all hash algorithms for the context.  */
2607               for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE)); )
2608                 if (!openpgp_md_test_algo (n1->pkt->pkt.signature->digest_algo))
2609                   gcry_md_enable (c->mfx.md,
2610                                   map_md_openpgp_to_gcry
2611                                   (n1->pkt->pkt.signature->digest_algo));
2612             }
2613
2614           if (RFC2440 || RFC4880)
2615             ; /* Strict RFC mode.  */
2616           else if (sig->digest_algo == DIGEST_ALGO_SHA1
2617                    && sig->pubkey_algo == PUBKEY_ALGO_DSA
2618                    && sig->sig_class == 0x01)
2619             {
2620               /* Enable a workaround for a pgp5 bug when the detached
2621                * signature has been created in textmode.  Note that we
2622                * do not implement this for multiple signatures with
2623                * different hash algorithms. */
2624               rc = gcry_md_open (&c->mfx.md2, sig->digest_algo, 0);
2625               if (rc)
2626                 goto detached_hash_err;
2627             }
2628
2629           /* Here we used to have another hack to work around a pgp
2630            * 2 bug: It worked by not using the textmode for detached
2631            * signatures; this would let the first signature check
2632            * (on md) fail but the second one (on md2), which adds an
2633            * extra CR would then have produced the "correct" hash.
2634            * This is very, very ugly hack but it may haved help in
2635            * some cases (and break others).
2636            *     c->mfx.md2? 0 :(sig->sig_class == 0x01)
2637            */
2638
2639           if (DBG_HASHING)
2640             {
2641               gcry_md_debug (c->mfx.md, "verify");
2642               if (c->mfx.md2)
2643                 gcry_md_debug (c->mfx.md2, "verify2");
2644             }
2645
2646           if (c->sigs_only)
2647             {
2648               if (c->signed_data.used && c->signed_data.data_fd != -1)
2649                 rc = hash_datafile_by_fd (c->mfx.md, c->mfx.md2,
2650                                           c->signed_data.data_fd,
2651                                           (sig->sig_class == 0x01));
2652               else
2653                 rc = hash_datafiles (c->mfx.md, c->mfx.md2,
2654                                      c->signed_data.data_names,
2655                                      c->sigfilename,
2656                                      (sig->sig_class == 0x01));
2657             }
2658           else
2659             {
2660               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2661                                               iobuf_get_real_fname(c->iobuf),
2662                                               (sig->sig_class == 0x01));
2663             }
2664
2665         detached_hash_err:
2666           if (rc)
2667             {
2668               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2669               return;
2670             }
2671         }
2672       else if (c->signed_data.used)
2673         {
2674           log_error (_("not a detached signature\n"));
2675           return;
2676         }
2677       else if (!opt.quiet)
2678         log_info (_("old style (PGP 2.x) signature\n"));
2679
2680       if (multiple_ok)
2681         {
2682           for (n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2683             check_sig_and_print (c, n1);
2684         }
2685       else
2686         check_sig_and_print (c, node);
2687
2688     }
2689   else
2690     {
2691       dump_kbnode (c->list);
2692       log_error ("invalid root packet detected in proc_tree()\n");
2693       dump_kbnode (node);
2694     }
2695 }