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