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