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