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