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