gpg: Fix printing of pubkey algo in --verbose signature verify.
[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 <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       rc = handle_plaintext (pt, &c->mfx, c->sigs_only, clearsig);
761       if (gpg_err_code (rc) == GPG_ERR_EACCES && !c->sigs_only)
762         {
763           /* Can't write output but we hash it anyway to check the
764              signature. */
765           rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
766         }
767     }
768
769   if (rc)
770     log_error ("handle plaintext failed: %s\n", gpg_strerror (rc));
771
772   free_packet(pkt);
773   c->last_was_session_key = 0;
774
775   /* We add a marker control packet instead of the plaintext packet.
776    * This is so that we can later detect invalid packet sequences.  */
777   n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
778   if (c->list)
779     add_kbnode (c->list, n);
780   else
781     c->list = n;
782 }
783
784
785 static int
786 proc_compressed_cb (iobuf_t a, void *info)
787 {
788   if ( ((CTX)info)->signed_data.used
789        && ((CTX)info)->signed_data.data_fd != -1)
790     return proc_signature_packets_by_fd (((CTX)info)->ctrl, info, a,
791                                          ((CTX)info)->signed_data.data_fd);
792   else
793     return proc_signature_packets (((CTX)info)->ctrl, info, a,
794                                    ((CTX)info)->signed_data.data_names,
795                                    ((CTX)info)->sigfilename );
796 }
797
798
799 static int
800 proc_encrypt_cb (iobuf_t a, void *info )
801 {
802   CTX c = info;
803   return proc_encryption_packets (c->ctrl, info, a );
804 }
805
806
807 static int
808 proc_compressed (CTX c, PACKET *pkt)
809 {
810   PKT_compressed *zd = pkt->pkt.compressed;
811   int rc;
812
813   /*printf("zip: compressed data packet\n");*/
814   if (c->sigs_only)
815     rc = handle_compressed (c->ctrl, c, zd, proc_compressed_cb, c);
816   else if( c->encrypt_only )
817     rc = handle_compressed (c->ctrl, c, zd, proc_encrypt_cb, c);
818   else
819     rc = handle_compressed (c->ctrl, c, zd, NULL, NULL);
820
821   if (gpg_err_code (rc) == GPG_ERR_BAD_DATA)
822     {
823       if  (!c->any.uncompress_failed)
824         {
825           CTX cc;
826
827           for (cc=c; cc; cc = cc->anchor)
828             cc->any.uncompress_failed = 1;
829           log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
830         }
831     }
832   else if (rc)
833     log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
834
835   free_packet(pkt);
836   c->last_was_session_key = 0;
837   return rc;
838 }
839
840
841 /*
842  * Check the signature.  If R_PK is not NULL a copy of the public key
843  * used to verify the signature will be stored tehre, or NULL if not
844  * found.  Returns: 0 = valid signature or an error code
845  */
846 static int
847 do_check_sig (CTX c, kbnode_t node, int *is_selfsig,
848               int *is_expkey, int *is_revkey, PKT_public_key **r_pk)
849 {
850   PKT_signature *sig;
851   gcry_md_hd_t md = NULL;
852   gcry_md_hd_t md2 = NULL;
853   gcry_md_hd_t md_good = NULL;
854   int algo, rc;
855
856   if (r_pk)
857     *r_pk = NULL;
858
859   log_assert (node->pkt->pkttype == PKT_SIGNATURE);
860   if (is_selfsig)
861     *is_selfsig = 0;
862   sig = node->pkt->pkt.signature;
863
864   algo = sig->digest_algo;
865   rc = openpgp_md_test_algo (algo);
866   if (rc)
867     return rc;
868
869   if (sig->sig_class == 0x00)
870     {
871       if (c->mfx.md)
872         {
873           if (gcry_md_copy (&md, c->mfx.md ))
874             BUG ();
875         }
876       else /* detached signature */
877         {
878           /* check_signature() will enable the md. */
879           if (gcry_md_open (&md, 0, 0 ))
880             BUG ();
881         }
882     }
883   else if (sig->sig_class == 0x01)
884     {
885       /* How do we know that we have to hash the (already hashed) text
886          in canonical mode ??? (calculating both modes???) */
887       if (c->mfx.md)
888         {
889           if (gcry_md_copy (&md, c->mfx.md ))
890             BUG ();
891           if (c->mfx.md2 && gcry_md_copy (&md2, c->mfx.md2))
892             BUG ();
893         }
894       else /* detached signature */
895         {
896           log_debug ("Do we really need this here?");
897           /* check_signature() will enable the md*/
898           if (gcry_md_open (&md, 0, 0 ))
899             BUG ();
900           if (gcry_md_open (&md2, 0, 0 ))
901             BUG ();
902         }
903     }
904   else if ((sig->sig_class&~3) == 0x10
905            ||   sig->sig_class == 0x18
906            ||   sig->sig_class == 0x1f
907            ||   sig->sig_class == 0x20
908            ||   sig->sig_class == 0x28
909            ||   sig->sig_class == 0x30)
910     {
911       if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
912           || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY)
913         {
914           return check_key_signature( c->list, node, is_selfsig );
915         }
916       else if (sig->sig_class == 0x20)
917         {
918           log_error (_("standalone revocation - "
919                        "use \"gpg --import\" to apply\n"));
920           return GPG_ERR_NOT_PROCESSED;
921         }
922       else
923         {
924           log_error ("invalid root packet for sigclass %02x\n", sig->sig_class);
925           return GPG_ERR_SIG_CLASS;
926         }
927     }
928   else
929     return GPG_ERR_SIG_CLASS;
930
931   /* We only get here if we are checking the signature of a binary
932      (0x00) or text document (0x01).  */
933   rc = check_signature2 (sig, md, NULL, is_expkey, is_revkey, r_pk);
934   if (! rc)
935     md_good = md;
936   else if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE && md2)
937     {
938       PKT_public_key *pk2;
939
940       rc = check_signature2 (sig, md2, NULL, is_expkey, is_revkey,
941                              r_pk? &pk2 : NULL);
942       if (!rc)
943         {
944           md_good = md2;
945           if (r_pk)
946             {
947               free_public_key (*r_pk);
948               *r_pk = pk2;
949             }
950         }
951     }
952
953   if (md_good)
954     {
955       unsigned char *buffer = gcry_md_read (md_good, sig->digest_algo);
956       sig->digest_len = gcry_md_get_algo_dlen (map_md_openpgp_to_gcry (algo));
957       memcpy (sig->digest, buffer, sig->digest_len);
958     }
959
960   gcry_md_close (md);
961   gcry_md_close (md2);
962
963   return rc;
964 }
965
966
967 static void
968 print_userid (PACKET *pkt)
969 {
970   if (!pkt)
971     BUG();
972
973   if (pkt->pkttype != PKT_USER_ID)
974     {
975       es_printf ("ERROR: unexpected packet type %d", pkt->pkttype );
976       return;
977     }
978   if (opt.with_colons)
979     {
980       if (pkt->pkt.user_id->attrib_data)
981         es_printf("%u %lu",
982                   pkt->pkt.user_id->numattribs,
983                   pkt->pkt.user_id->attrib_len);
984       else
985         es_write_sanitized (es_stdout, pkt->pkt.user_id->name,
986                             pkt->pkt.user_id->len, ":", NULL);
987     }
988   else
989     print_utf8_buffer (es_stdout, pkt->pkt.user_id->name,
990                        pkt->pkt.user_id->len );
991 }
992
993
994 /*
995  * List the keyblock in a user friendly way
996  */
997 static void
998 list_node (CTX c, kbnode_t node)
999 {
1000   if (!node)
1001     ;
1002   else if (node->pkt->pkttype == PKT_PUBLIC_KEY
1003            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1004     {
1005       PKT_public_key *pk = node->pkt->pkt.public_key;
1006
1007       if (opt.with_colons)
1008         {
1009           u32 keyid[2];
1010
1011           keyid_from_pk( pk, keyid );
1012           if (pk->flags.primary)
1013             c->trustletter = (opt.fast_list_mode?
1014                               0 : get_validity_info (c->ctrl, pk, NULL));
1015           es_printf ("%s:", pk->flags.primary? "pub":"sub" );
1016           if (c->trustletter)
1017             es_putc (c->trustletter, es_stdout);
1018           es_printf (":%u:%d:%08lX%08lX:%s:%s::",
1019                      nbits_from_pk( pk ),
1020                      pk->pubkey_algo,
1021                      (ulong)keyid[0],(ulong)keyid[1],
1022                      colon_datestr_from_pk( pk ),
1023                      colon_strtime (pk->expiredate) );
1024           if (pk->flags.primary && !opt.fast_list_mode)
1025             es_putc (get_ownertrust_info (pk), es_stdout);
1026           es_putc (':', es_stdout);
1027           es_putc ('\n', es_stdout);
1028         }
1029       else
1030         {
1031           print_key_line (es_stdout, pk, 0);
1032         }
1033
1034       if (opt.keyid_format == KF_NONE && !opt.with_colons)
1035         ; /* Already printed.  */
1036       else if ((pk->flags.primary && opt.fingerprint) || opt.fingerprint > 1)
1037         print_fingerprint (NULL, pk, 0);
1038
1039       if (opt.with_colons)
1040         {
1041           if (node->next && node->next->pkt->pkttype == PKT_RING_TRUST)
1042             es_printf ("rtv:1:%u:\n",
1043                        node->next->pkt->pkt.ring_trust->trustval);
1044         }
1045
1046       if (pk->flags.primary)
1047         {
1048           int kl = opt.keyid_format == KF_NONE? 0 : keystrlen ();
1049
1050           /* Now list all userids with their signatures. */
1051           for (node = node->next; node; node = node->next)
1052             {
1053               if (node->pkt->pkttype == PKT_SIGNATURE)
1054                 {
1055                   list_node (c,  node );
1056                 }
1057               else if (node->pkt->pkttype == PKT_USER_ID)
1058                 {
1059                   if (opt.with_colons)
1060                     es_printf ("%s:::::::::",
1061                                node->pkt->pkt.user_id->attrib_data?"uat":"uid");
1062                   else
1063                     es_printf ("uid%*s",
1064                                kl + (opt.legacy_list_mode? 9:11),
1065                                "" );
1066                   print_userid (node->pkt);
1067                   if (opt.with_colons)
1068                     es_putc (':', es_stdout);
1069                   es_putc ('\n', es_stdout);
1070                   if (opt.with_colons
1071                       && node->next
1072                       && node->next->pkt->pkttype == PKT_RING_TRUST)
1073                     {
1074                       es_printf ("rtv:2:%u:\n",
1075                                  node->next->pkt->pkt.ring_trust?
1076                                  node->next->pkt->pkt.ring_trust->trustval : 0);
1077                     }
1078                 }
1079               else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1080                 {
1081                   list_node(c,  node );
1082                 }
1083             }
1084         }
1085     }
1086   else if (node->pkt->pkttype == PKT_SECRET_KEY
1087            || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1088     {
1089
1090       log_debug ("FIXME: No way to print secret key packets here\n");
1091       /* fixme: We may use a function to turn a secret key packet into
1092          a public key one and use that here.  */
1093     }
1094   else if (node->pkt->pkttype == PKT_SIGNATURE)
1095     {
1096       PKT_signature *sig = node->pkt->pkt.signature;
1097       int is_selfsig = 0;
1098       int rc2 = 0;
1099       size_t n;
1100       char *p;
1101       int sigrc = ' ';
1102
1103       if (!opt.verbose)
1104         return;
1105
1106       if (sig->sig_class == 0x20 || sig->sig_class == 0x30)
1107         es_fputs ("rev", es_stdout);
1108       else
1109         es_fputs ("sig", es_stdout);
1110       if (opt.check_sigs)
1111         {
1112           fflush (stdout);
1113           rc2 = do_check_sig (c, node, &is_selfsig, NULL, NULL, NULL);
1114           switch (gpg_err_code (rc2))
1115             {
1116             case 0:                       sigrc = '!'; break;
1117             case GPG_ERR_BAD_SIGNATURE:   sigrc = '-'; break;
1118             case GPG_ERR_NO_PUBKEY:
1119             case GPG_ERR_UNUSABLE_PUBKEY: sigrc = '?'; break;
1120             default:                      sigrc = '%'; break;
1121             }
1122         }
1123       else /* Check whether this is a self signature.  */
1124         {
1125           u32 keyid[2];
1126
1127           if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
1128               || c->list->pkt->pkttype == PKT_SECRET_KEY )
1129             {
1130               keyid_from_pk (c->list->pkt->pkt.public_key, keyid);
1131
1132               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
1133                 is_selfsig = 1;
1134             }
1135         }
1136
1137       if (opt.with_colons)
1138         {
1139           es_putc (':', es_stdout);
1140           if (sigrc != ' ')
1141             es_putc (sigrc, es_stdout);
1142           es_printf ("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1143                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1144                      colon_datestr_from_sig (sig),
1145                      colon_expirestr_from_sig (sig));
1146
1147           if (sig->trust_depth || sig->trust_value)
1148             es_printf ("%d %d",sig->trust_depth,sig->trust_value);
1149           es_putc (':', es_stdout);
1150
1151           if (sig->trust_regexp)
1152             es_write_sanitized (es_stdout, sig->trust_regexp,
1153                                 strlen (sig->trust_regexp), ":", NULL);
1154           es_putc (':', es_stdout);
1155         }
1156       else
1157         es_printf ("%c       %s %s   ",
1158                    sigrc, keystr (sig->keyid), datestr_from_sig(sig));
1159       if (sigrc == '%')
1160         es_printf ("[%s] ", gpg_strerror (rc2) );
1161       else if (sigrc == '?')
1162         ;
1163       else if (is_selfsig)
1164         {
1165           if (opt.with_colons)
1166             es_putc (':', es_stdout);
1167           es_fputs (sig->sig_class == 0x18? "[keybind]":"[selfsig]", es_stdout);
1168           if (opt.with_colons)
1169             es_putc (':', es_stdout);
1170         }
1171       else if (!opt.fast_list_mode)
1172         {
1173           p = get_user_id (sig->keyid, &n);
1174           es_write_sanitized (es_stdout, p, n,
1175                               opt.with_colons?":":NULL, NULL );
1176           xfree (p);
1177         }
1178       if (opt.with_colons)
1179         es_printf (":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1180       es_putc ('\n', es_stdout);
1181     }
1182   else
1183     log_error ("invalid node with packet of type %d\n", node->pkt->pkttype);
1184 }
1185
1186
1187 int
1188 proc_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1189 {
1190   int rc;
1191   CTX c = xmalloc_clear (sizeof *c);
1192
1193   c->ctrl = ctrl;
1194   c->anchor = anchor;
1195   rc = do_proc_packets (ctrl, c, a);
1196   xfree (c);
1197
1198   return rc;
1199 }
1200
1201
1202 int
1203 proc_signature_packets (ctrl_t ctrl, void *anchor, iobuf_t a,
1204                         strlist_t signedfiles, const char *sigfilename )
1205 {
1206   CTX c = xmalloc_clear (sizeof *c);
1207   int rc;
1208
1209   c->ctrl = ctrl;
1210   c->anchor = anchor;
1211   c->sigs_only = 1;
1212
1213   c->signed_data.data_fd = -1;
1214   c->signed_data.data_names = signedfiles;
1215   c->signed_data.used = !!signedfiles;
1216
1217   c->sigfilename = sigfilename;
1218   rc = do_proc_packets (ctrl, c, a);
1219
1220   /* If we have not encountered any signature we print an error
1221      messages, send a NODATA status back and return an error code.
1222      Using log_error is required because verify_files does not check
1223      error codes for each file but we want to terminate the process
1224      with an error. */
1225   if (!rc && !c->any.sig_seen)
1226     {
1227       write_status_text (STATUS_NODATA, "4");
1228       log_error (_("no signature found\n"));
1229       rc = GPG_ERR_NO_DATA;
1230     }
1231
1232   /* Propagate the signature seen flag upward. Do this only on success
1233      so that we won't issue the nodata status several times.  */
1234   if (!rc && c->anchor && c->any.sig_seen)
1235     c->anchor->any.sig_seen = 1;
1236
1237   xfree (c);
1238   return rc;
1239 }
1240
1241
1242 int
1243 proc_signature_packets_by_fd (ctrl_t ctrl,
1244                               void *anchor, iobuf_t a, int signed_data_fd )
1245 {
1246   int rc;
1247   CTX c;
1248
1249   c = xtrycalloc (1, sizeof *c);
1250   if (!c)
1251     return gpg_error_from_syserror ();
1252
1253   c->ctrl = ctrl;
1254   c->anchor = anchor;
1255   c->sigs_only = 1;
1256
1257   c->signed_data.data_fd = signed_data_fd;
1258   c->signed_data.data_names = NULL;
1259   c->signed_data.used = (signed_data_fd != -1);
1260
1261   rc = do_proc_packets (ctrl, c, a);
1262
1263   /* If we have not encountered any signature we print an error
1264      messages, send a NODATA status back and return an error code.
1265      Using log_error is required because verify_files does not check
1266      error codes for each file but we want to terminate the process
1267      with an error. */
1268   if (!rc && !c->any.sig_seen)
1269     {
1270       write_status_text (STATUS_NODATA, "4");
1271       log_error (_("no signature found\n"));
1272       rc = gpg_error (GPG_ERR_NO_DATA);
1273     }
1274
1275   /* Propagate the signature seen flag upward. Do this only on success
1276      so that we won't issue the nodata status several times. */
1277   if (!rc && c->anchor && c->any.sig_seen)
1278     c->anchor->any.sig_seen = 1;
1279
1280   xfree ( c );
1281   return rc;
1282 }
1283
1284
1285 int
1286 proc_encryption_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1287 {
1288   CTX c = xmalloc_clear (sizeof *c);
1289   int rc;
1290
1291   c->ctrl = ctrl;
1292   c->anchor = anchor;
1293   c->encrypt_only = 1;
1294   rc = do_proc_packets (ctrl, c, a);
1295   xfree (c);
1296   return rc;
1297 }
1298
1299
1300 static int
1301 check_nesting (CTX c)
1302 {
1303   int level;
1304
1305   for (level=0; c; c = c->anchor)
1306     level++;
1307
1308   if (level > MAX_NESTING_DEPTH)
1309     {
1310       log_error ("input data with too deeply nested packets\n");
1311       write_status_text (STATUS_UNEXPECTED, "1");
1312       return GPG_ERR_BAD_DATA;
1313     }
1314
1315   return 0;
1316 }
1317
1318
1319 static int
1320 do_proc_packets (ctrl_t ctrl, CTX c, iobuf_t a)
1321 {
1322   PACKET *pkt;
1323   int rc = 0;
1324   int any_data = 0;
1325   int newpkt;
1326
1327   rc = check_nesting (c);
1328   if (rc)
1329     return rc;
1330
1331   pkt = xmalloc( sizeof *pkt );
1332   c->iobuf = a;
1333   init_packet(pkt);
1334   while ((rc=parse_packet(a, pkt)) != -1)
1335     {
1336       any_data = 1;
1337       if (rc)
1338         {
1339           free_packet (pkt);
1340           /* Stop processing when an invalid packet has been encountered
1341            * but don't do so when we are doing a --list-packets.  */
1342           if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
1343               && opt.list_packets == 0)
1344             break;
1345           continue;
1346         }
1347       newpkt = -1;
1348       if (opt.list_packets)
1349         {
1350           switch (pkt->pkttype)
1351             {
1352             case PKT_PUBKEY_ENC:    proc_pubkey_enc (ctrl, c, pkt); break;
1353             case PKT_SYMKEY_ENC:    proc_symkey_enc (c, pkt); break;
1354             case PKT_ENCRYPTED:
1355             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1356             case PKT_COMPRESSED:    rc = proc_compressed (c, pkt); break;
1357             default: newpkt = 0; break;
1358             }
1359         }
1360       else if (c->sigs_only)
1361         {
1362           switch (pkt->pkttype)
1363             {
1364             case PKT_PUBLIC_KEY:
1365             case PKT_SECRET_KEY:
1366             case PKT_USER_ID:
1367             case PKT_SYMKEY_ENC:
1368             case PKT_PUBKEY_ENC:
1369             case PKT_ENCRYPTED:
1370             case PKT_ENCRYPTED_MDC:
1371               write_status_text( STATUS_UNEXPECTED, "0" );
1372               rc = GPG_ERR_UNEXPECTED;
1373               goto leave;
1374
1375             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1376             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1377             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1378             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1379             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1380             default: newpkt = 0; break;
1381             }
1382         }
1383       else if (c->encrypt_only)
1384         {
1385           switch (pkt->pkttype)
1386             {
1387             case PKT_PUBLIC_KEY:
1388             case PKT_SECRET_KEY:
1389             case PKT_USER_ID:
1390               write_status_text (STATUS_UNEXPECTED, "0");
1391               rc = GPG_ERR_UNEXPECTED;
1392               goto leave;
1393
1394             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1395             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1396             case PKT_PUBKEY_ENC:  proc_pubkey_enc (ctrl, c, pkt); break;
1397             case PKT_ENCRYPTED:
1398             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1399             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1400             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1401             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1402             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1403             default: newpkt = 0; break;
1404             }
1405         }
1406       else
1407         {
1408           switch (pkt->pkttype)
1409             {
1410             case PKT_PUBLIC_KEY:
1411             case PKT_SECRET_KEY:
1412               release_list (c);
1413               c->list = new_kbnode (pkt);
1414               newpkt = 1;
1415               break;
1416             case PKT_PUBLIC_SUBKEY:
1417             case PKT_SECRET_SUBKEY:
1418               newpkt = add_subkey (c, pkt);
1419               break;
1420             case PKT_USER_ID:     newpkt = add_user_id (c, pkt); break;
1421             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1422             case PKT_PUBKEY_ENC:  proc_pubkey_enc (ctrl, c, pkt); break;
1423             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1424             case PKT_ENCRYPTED:
1425             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1426             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1427             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1428             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1429             case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1430             case PKT_RING_TRUST:  newpkt = add_ring_trust (c, pkt); break;
1431             default: newpkt = 0; break;
1432             }
1433         }
1434
1435       if (rc)
1436         goto leave;
1437
1438       /* This is a very ugly construct and frankly, I don't remember why
1439        * I used it.  Adding the MDC check here is a hack.
1440        * The right solution is to initiate another context for encrypted
1441        * packet and not to reuse the current one ...  It works right
1442        * when there is a compression packet between which adds just
1443        * an extra layer.
1444        * Hmmm: Rewrite this whole module here??
1445        */
1446       if (pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC)
1447         c->any.data = (pkt->pkttype == PKT_PLAINTEXT);
1448
1449       if (newpkt == -1)
1450         ;
1451       else if (newpkt)
1452         {
1453           pkt = xmalloc (sizeof *pkt);
1454           init_packet (pkt);
1455         }
1456       else
1457         free_packet(pkt);
1458     }
1459
1460   if (rc == GPG_ERR_INV_PACKET)
1461     write_status_text (STATUS_NODATA, "3");
1462
1463   if (any_data)
1464     rc = 0;
1465   else if (rc == -1)
1466     write_status_text (STATUS_NODATA, "2");
1467
1468
1469  leave:
1470   release_list (c);
1471   xfree(c->dek);
1472   free_packet (pkt);
1473   xfree (pkt);
1474   free_md_filter_context (&c->mfx);
1475   return rc;
1476 }
1477
1478
1479 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1480    of the notation data. */
1481 static pka_info_t *
1482 get_pka_address (PKT_signature *sig)
1483 {
1484   pka_info_t *pka = NULL;
1485   struct notation *nd,*notation;
1486
1487   notation=sig_to_notation(sig);
1488
1489   for(nd=notation;nd;nd=nd->next)
1490     {
1491       if(strcmp(nd->name,"pka-address@gnupg.org")!=0)
1492         continue; /* Not the notation we want. */
1493
1494       /* For now we only use the first valid PKA notation. In future
1495          we might want to keep additional PKA notations in a linked
1496          list. */
1497       if (is_valid_mailbox (nd->value))
1498         {
1499           pka = xmalloc (sizeof *pka + strlen(nd->value));
1500           pka->valid = 0;
1501           pka->checked = 0;
1502           pka->uri = NULL;
1503           strcpy (pka->email, nd->value);
1504           break;
1505         }
1506     }
1507
1508   free_notation(notation);
1509
1510   return pka;
1511 }
1512
1513
1514 /* Return the URI from a DNS PKA record.  If this record has already
1515    be retrieved for the signature we merely return it; if not we go
1516    out and try to get that DNS record. */
1517 static const char *
1518 pka_uri_from_sig (CTX c, PKT_signature *sig)
1519 {
1520   if (!sig->flags.pka_tried)
1521     {
1522       log_assert (!sig->pka_info);
1523       sig->flags.pka_tried = 1;
1524       sig->pka_info = get_pka_address (sig);
1525       if (sig->pka_info)
1526         {
1527           char *url;
1528           unsigned char *fpr;
1529           size_t fprlen;
1530
1531           if (!gpg_dirmngr_get_pka (c->ctrl, sig->pka_info->email,
1532                                     &fpr, &fprlen, &url))
1533             {
1534               if (fpr && fprlen == sizeof sig->pka_info->fpr)
1535                 {
1536                   memcpy (sig->pka_info->fpr, fpr, fprlen);
1537                   if (url)
1538                     {
1539                       sig->pka_info->valid = 1;
1540                       if (!*url)
1541                         xfree (url);
1542                       else
1543                         sig->pka_info->uri = url;
1544                       url = NULL;
1545                     }
1546                 }
1547               xfree (fpr);
1548               xfree (url);
1549             }
1550         }
1551     }
1552   return sig->pka_info? sig->pka_info->uri : NULL;
1553 }
1554
1555
1556 /* Return true if the AKL has the WKD method specified.  */
1557 static int
1558 akl_has_wkd_method (void)
1559 {
1560   struct akl *akl;
1561
1562   for (akl = opt.auto_key_locate; akl; akl = akl->next)
1563     if (akl->type == AKL_WKD)
1564       return 1;
1565   return 0;
1566 }
1567
1568
1569 /* Return the ISSUER fingerprint string in human readbale format if
1570  * available.  Caller must release the string.  */
1571 static char *
1572 issuer_fpr_string (PKT_signature *sig)
1573 {
1574   const byte *p;
1575   size_t n;
1576
1577   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_ISSUER_FPR, &n);
1578   if (p && n == 21 && p[0] == 4)
1579     return bin2hex (p+1, n-1, NULL);
1580   return NULL;
1581 }
1582
1583
1584 static void
1585 print_good_bad_signature (int statno, const char *keyid_str, kbnode_t un,
1586                           PKT_signature *sig, int rc)
1587 {
1588   char *p;
1589
1590   write_status_text_and_buffer (statno, keyid_str,
1591                                 un? un->pkt->pkt.user_id->name:"[?]",
1592                                 un? un->pkt->pkt.user_id->len:3,
1593                                 -1);
1594
1595   if (un)
1596     p = utf8_to_native (un->pkt->pkt.user_id->name,
1597                         un->pkt->pkt.user_id->len, 0);
1598   else
1599     p = xstrdup ("[?]");
1600
1601   if (rc)
1602     log_info (_("BAD signature from \"%s\""), p);
1603   else if (sig->flags.expired)
1604     log_info (_("Expired signature from \"%s\""), p);
1605   else
1606     log_info (_("Good signature from \"%s\""), p);
1607
1608   xfree (p);
1609 }
1610
1611
1612 static int
1613 check_sig_and_print (CTX c, kbnode_t node)
1614 {
1615   PKT_signature *sig = node->pkt->pkt.signature;
1616   const char *astr;
1617   int rc;
1618   int is_expkey = 0;
1619   int is_revkey = 0;
1620   char *issuer_fpr;
1621   PKT_public_key *pk = NULL;  /* The public key for the signature or NULL. */
1622
1623   if (opt.skip_verify)
1624     {
1625       log_info(_("signature verification suppressed\n"));
1626       return 0;
1627     }
1628
1629   /* Check that the message composition is valid.
1630    *
1631    * Per RFC-2440bis (-15) allowed:
1632    *
1633    * S{1,n}           -- detached signature.
1634    * S{1,n} P         -- old style PGP2 signature
1635    * O{1,n} P S{1,n}  -- standard OpenPGP signature.
1636    * C P S{1,n}       -- cleartext signature.
1637    *
1638    *
1639    *      O = One-Pass Signature packet.
1640    *      S = Signature packet.
1641    *      P = OpenPGP Message packet (Encrypted | Compressed | Literal)
1642    *             (Note that the current rfc2440bis draft also allows
1643    *              for a signed message but that does not work as it
1644    *              introduces ambiguities.)
1645    *          We keep track of these packages using the marker packet
1646    *          CTRLPKT_PLAINTEXT_MARK.
1647    *      C = Marker packet for cleartext signatures.
1648    *
1649    * We reject all other messages.
1650    *
1651    * Actually we are calling this too often, i.e. for verification of
1652    * each message but better have some duplicate work than to silently
1653    * introduce a bug here.
1654    */
1655   {
1656     kbnode_t n;
1657     int n_onepass, n_sig;
1658
1659 /*     log_debug ("checking signature packet composition\n"); */
1660 /*     dump_kbnode (c->list); */
1661
1662     n = c->list;
1663     log_assert (n);
1664     if ( n->pkt->pkttype == PKT_SIGNATURE )
1665       {
1666         /* This is either "S{1,n}" case (detached signature) or
1667            "S{1,n} P" (old style PGP2 signature). */
1668         for (n = n->next; n; n = n->next)
1669           if (n->pkt->pkttype != PKT_SIGNATURE)
1670             break;
1671         if (!n)
1672           ; /* Okay, this is a detached signature.  */
1673         else if (n->pkt->pkttype == PKT_GPG_CONTROL
1674                  && (n->pkt->pkt.gpg_control->control
1675                      == CTRLPKT_PLAINTEXT_MARK) )
1676           {
1677             if (n->next)
1678               goto ambiguous;  /* We only allow one P packet. */
1679           }
1680         else
1681           goto ambiguous;
1682       }
1683     else if (n->pkt->pkttype == PKT_ONEPASS_SIG)
1684       {
1685         /* This is the "O{1,n} P S{1,n}" case (standard signature). */
1686         for (n_onepass=1, n = n->next;
1687              n && n->pkt->pkttype == PKT_ONEPASS_SIG; n = n->next)
1688           n_onepass++;
1689         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1690                     && (n->pkt->pkt.gpg_control->control
1691                         == CTRLPKT_PLAINTEXT_MARK)))
1692           goto ambiguous;
1693         for (n_sig=0, n = n->next;
1694              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1695           n_sig++;
1696         if (!n_sig)
1697           goto ambiguous;
1698
1699         /* If we wanted to disallow multiple sig verification, we'd do
1700            something like this:
1701
1702            if (n && !opt.allow_multisig_verification)
1703              goto ambiguous;
1704
1705            However, now that we have --allow-multiple-messages, this
1706            can stay allowable as we can't get here unless multiple
1707            messages (i.e. multiple literals) are allowed. */
1708
1709         if (n_onepass != n_sig)
1710           {
1711             log_info ("number of one-pass packets does not match "
1712                       "number of signature packets\n");
1713             goto ambiguous;
1714           }
1715       }
1716     else if (n->pkt->pkttype == PKT_GPG_CONTROL
1717              && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
1718       {
1719         /* This is the "C P S{1,n}" case (clear text signature). */
1720         n = n->next;
1721         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1722                     && (n->pkt->pkt.gpg_control->control
1723                         == CTRLPKT_PLAINTEXT_MARK)))
1724           goto ambiguous;
1725         for (n_sig=0, n = n->next;
1726              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1727           n_sig++;
1728         if (n || !n_sig)
1729           goto ambiguous;
1730       }
1731     else
1732       {
1733       ambiguous:
1734         log_error(_("can't handle this ambiguous signature data\n"));
1735         return 0;
1736       }
1737   }
1738
1739   if (sig->signers_uid)
1740     write_status_buffer (STATUS_NEWSIG,
1741                          sig->signers_uid, strlen (sig->signers_uid), 0);
1742   else
1743     write_status_text (STATUS_NEWSIG, NULL);
1744
1745   astr = openpgp_pk_algo_name ( sig->pubkey_algo );
1746   if (opt.flags.rfc4880bis && (issuer_fpr = issuer_fpr_string (sig)))
1747     {
1748       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1749       log_info (_("               using %s key %s\n"),
1750                 astr? astr: "?", issuer_fpr);
1751
1752       xfree (issuer_fpr);
1753     }
1754   else if (!keystrlen () || keystrlen () > 8)
1755     {
1756       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1757       log_info (_("               using %s key %s\n"),
1758                 astr? astr: "?", keystr(sig->keyid));
1759     }
1760   else /* Legacy format.  */
1761     log_info (_("Signature made %s using %s key ID %s\n"),
1762               asctimestamp(sig->timestamp), astr? astr: "?",
1763               keystr(sig->keyid));
1764
1765   /* In verbose mode print the signers UID.  */
1766   if (sig->signers_uid)
1767     log_info (_("               issuer \"%s\"\n"), sig->signers_uid);
1768
1769   rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
1770
1771   /* If the key isn't found, check for a preferred keyserver.  */
1772   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY && sig->flags.pref_ks)
1773     {
1774       const byte *p;
1775       int seq = 0;
1776       size_t n;
1777
1778       while ((p=enum_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1779         {
1780           /* According to my favorite copy editor, in English grammar,
1781              you say "at" if the key is located on a web page, but
1782              "from" if it is located on a keyserver.  I'm not going to
1783              even try to make two strings here :) */
1784           log_info(_("Key available at: ") );
1785           print_utf8_buffer (log_get_stream(), p, n);
1786           log_printf ("\n");
1787
1788           if (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1789               && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1790             {
1791               struct keyserver_spec *spec;
1792
1793               spec = parse_preferred_keyserver (sig);
1794               if (spec)
1795                 {
1796                   int res;
1797
1798                   free_public_key (pk);
1799                   pk = NULL;
1800                   glo_ctrl.in_auto_key_retrieve++;
1801                   res = keyserver_import_keyid (c->ctrl, sig->keyid,spec);
1802                   glo_ctrl.in_auto_key_retrieve--;
1803                   if (!res)
1804                     rc = do_check_sig (c, node, NULL,
1805                                        &is_expkey, &is_revkey, &pk);
1806                   free_keyserver_spec (spec);
1807
1808                   if (!rc)
1809                     break;
1810                 }
1811             }
1812         }
1813     }
1814
1815   /* If the avove methods didn't work, our next try is to use the URI
1816    * from a DNS PKA record.  */
1817   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1818       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
1819       && (opt.keyserver_options.options & KEYSERVER_HONOR_PKA_RECORD))
1820     {
1821       const char *uri = pka_uri_from_sig (c, sig);
1822
1823       if (uri)
1824         {
1825           /* FIXME: We might want to locate the key using the
1826              fingerprint instead of the keyid. */
1827           int res;
1828           struct keyserver_spec *spec;
1829
1830           spec = parse_keyserver_uri (uri, 1);
1831           if (spec)
1832             {
1833               free_public_key (pk);
1834               pk = NULL;
1835               glo_ctrl.in_auto_key_retrieve++;
1836               res = keyserver_import_keyid (c->ctrl, sig->keyid, spec);
1837               glo_ctrl.in_auto_key_retrieve--;
1838               free_keyserver_spec (spec);
1839               if (!res)
1840                 rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
1841             }
1842         }
1843     }
1844
1845   /* If the above methods didn't work, our next try is to use locate
1846    * the key via its fingerprint from a keyserver.  This requires
1847    * that the signers fingerprint is encoded in the signature.  We
1848    * favor this over the WKD method (to be tried next), because an
1849    * arbitrary keyserver is less subject to web bug like
1850    * monitoring.  */
1851   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1852       && opt.flags.rfc4880bis
1853       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
1854       && keyserver_any_configured (c->ctrl))
1855     {
1856       int res;
1857       const byte *p;
1858       size_t n;
1859
1860       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_ISSUER_FPR, &n);
1861       if (p && n == 21 && p[0] == 4)
1862         {
1863           /* v4 packet with a SHA-1 fingerprint.  */
1864           free_public_key (pk);
1865           pk = NULL;
1866           glo_ctrl.in_auto_key_retrieve++;
1867           res = keyserver_import_fprint (c->ctrl, p+1, n-1, opt.keyserver);
1868           glo_ctrl.in_auto_key_retrieve--;
1869           if (!res)
1870             rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
1871         }
1872     }
1873
1874   /* If the above methods didn't work, our next try is to retrieve the
1875    * key from the WKD. */
1876   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1877       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
1878       && !opt.flags.disable_signer_uid
1879       && akl_has_wkd_method ()
1880       && sig->signers_uid)
1881     {
1882       int res;
1883
1884       free_public_key (pk);
1885       pk = NULL;
1886       glo_ctrl.in_auto_key_retrieve++;
1887       res = keyserver_import_wkd (c->ctrl, sig->signers_uid, NULL, NULL);
1888       glo_ctrl.in_auto_key_retrieve--;
1889       /* Fixme: If the fingerprint is embedded in the signature,
1890        * compare it to the fingerprint of the returned key.  */
1891       if (!res)
1892         rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
1893     }
1894
1895   /* If the above methods did't work, our next try is to use a
1896    * keyserver.  */
1897   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1898       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
1899       && keyserver_any_configured (c->ctrl))
1900     {
1901       int res;
1902
1903       free_public_key (pk);
1904       pk = NULL;
1905       glo_ctrl.in_auto_key_retrieve++;
1906       res = keyserver_import_keyid (c->ctrl, sig->keyid, opt.keyserver );
1907       glo_ctrl.in_auto_key_retrieve--;
1908       if (!res)
1909         rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey, &pk);
1910     }
1911
1912   if (!rc || gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
1913     {
1914       kbnode_t un, keyblock;
1915       int count = 0;
1916       int statno;
1917       char keyid_str[50];
1918       PKT_public_key *mainpk = NULL;
1919
1920       if (rc)
1921         statno = STATUS_BADSIG;
1922       else if (sig->flags.expired)
1923         statno = STATUS_EXPSIG;
1924       else if (is_expkey)
1925         statno = STATUS_EXPKEYSIG;
1926       else if(is_revkey)
1927         statno = STATUS_REVKEYSIG;
1928       else
1929         statno = STATUS_GOODSIG;
1930
1931       /* FIXME: We should have the public key in PK and thus the
1932        * keyboock has already been fetched.  Thus we could use the
1933        * fingerprint or PK itself to lookup the entire keyblock.  That
1934        * would best be done with a cache.  */
1935       keyblock = get_pubkeyblock (sig->keyid);
1936
1937       snprintf (keyid_str, sizeof keyid_str, "%08lX%08lX [uncertain] ",
1938                 (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1939
1940       /* Find and print the primary user ID along with the
1941          "Good|Expired|Bad signature" line.  */
1942       for (un=keyblock; un; un = un->next)
1943         {
1944           int valid;
1945
1946           if (un->pkt->pkttype==PKT_PUBLIC_KEY)
1947             {
1948               mainpk = un->pkt->pkt.public_key;
1949               continue;
1950             }
1951           if (un->pkt->pkttype != PKT_USER_ID)
1952             continue;
1953           if (!un->pkt->pkt.user_id->created)
1954             continue;
1955           if (un->pkt->pkt.user_id->is_revoked)
1956             continue;
1957           if (un->pkt->pkt.user_id->is_expired)
1958             continue;
1959           if (!un->pkt->pkt.user_id->is_primary)
1960             continue;
1961           /* We want the textual primary user ID here */
1962           if (un->pkt->pkt.user_id->attrib_data)
1963             continue;
1964
1965           log_assert (mainpk);
1966
1967           /* Since this is just informational, don't actually ask the
1968              user to update any trust information.  (Note: we register
1969              the signature later.)  Because print_good_bad_signature
1970              does not print a LF we need to compute the validity
1971              before calling that function.  */
1972           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
1973             valid = get_validity (c->ctrl, mainpk, un->pkt->pkt.user_id,
1974                                   sig, 0);
1975           else
1976             valid = 0; /* Not used.  */
1977
1978           keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1979
1980           print_good_bad_signature (statno, keyid_str, un, sig, rc);
1981
1982           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
1983             log_printf (" [%s]\n",trust_value_to_string(valid));
1984           else
1985             log_printf ("\n");
1986
1987           count++;
1988         }
1989
1990       log_assert (mainpk);
1991
1992       /* In case we did not found a valid valid textual userid above
1993          we print the first user id packet or a "[?]" instead along
1994          with the "Good|Expired|Bad signature" line.  */
1995       if (!count)
1996         {
1997           /* Try for an invalid textual userid */
1998           for (un=keyblock; un; un = un->next)
1999             {
2000               if (un->pkt->pkttype == PKT_USER_ID
2001                   && !un->pkt->pkt.user_id->attrib_data)
2002                 break;
2003             }
2004
2005           /* Try for any userid at all */
2006           if (!un)
2007             {
2008               for (un=keyblock; un; un = un->next)
2009                 {
2010                   if (un->pkt->pkttype == PKT_USER_ID)
2011                     break;
2012                 }
2013             }
2014
2015           if (opt.trust_model==TM_ALWAYS || !un)
2016             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
2017
2018           print_good_bad_signature (statno, keyid_str, un, sig, rc);
2019
2020           if (opt.trust_model != TM_ALWAYS && un)
2021             log_printf (" %s",_("[uncertain]") );
2022           log_printf ("\n");
2023         }
2024
2025       /* If we have a good signature and already printed
2026        * the primary user ID, print all the other user IDs */
2027       if (count
2028           && !rc
2029           && !(opt.verify_options & VERIFY_SHOW_PRIMARY_UID_ONLY))
2030         {
2031           char *p;
2032           for( un=keyblock; un; un = un->next)
2033             {
2034               if (un->pkt->pkttype != PKT_USER_ID)
2035                 continue;
2036               if ((un->pkt->pkt.user_id->is_revoked
2037                    || un->pkt->pkt.user_id->is_expired)
2038                   && !(opt.verify_options & VERIFY_SHOW_UNUSABLE_UIDS))
2039                 continue;
2040               /* Skip textual primary user ids which we printed above. */
2041               if (un->pkt->pkt.user_id->is_primary
2042                   && !un->pkt->pkt.user_id->attrib_data )
2043                 continue;
2044
2045               /* If this user id has attribute data, print that.  */
2046               if (un->pkt->pkt.user_id->attrib_data)
2047                 {
2048                   dump_attribs (un->pkt->pkt.user_id, mainpk);
2049
2050                   if (opt.verify_options&VERIFY_SHOW_PHOTOS)
2051                     show_photos (c->ctrl,
2052                                  un->pkt->pkt.user_id->attribs,
2053                                  un->pkt->pkt.user_id->numattribs,
2054                                  mainpk ,un->pkt->pkt.user_id);
2055                 }
2056
2057               p = utf8_to_native (un->pkt->pkt.user_id->name,
2058                                   un->pkt->pkt.user_id->len, 0);
2059               log_info (_("                aka \"%s\""), p);
2060               xfree (p);
2061
2062               if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
2063                 {
2064                   const char *valid;
2065
2066                   if (un->pkt->pkt.user_id->is_revoked)
2067                     valid = _("revoked");
2068                   else if (un->pkt->pkt.user_id->is_expired)
2069                     valid = _("expired");
2070                   else
2071                     /* Since this is just informational, don't
2072                        actually ask the user to update any trust
2073                        information.  */
2074                     valid = (trust_value_to_string
2075                              (get_validity (c->ctrl, mainpk,
2076                                             un->pkt->pkt.user_id, sig, 0)));
2077                   log_printf (" [%s]\n",valid);
2078                 }
2079               else
2080                 log_printf ("\n");
2081             }
2082         }
2083
2084       /* For good signatures print notation data.  */
2085       if (!rc)
2086         {
2087           if ((opt.verify_options & VERIFY_SHOW_POLICY_URLS))
2088             show_policy_url (sig, 0, 1);
2089           else
2090             show_policy_url (sig, 0, 2);
2091
2092           if ((opt.verify_options & VERIFY_SHOW_KEYSERVER_URLS))
2093             show_keyserver_url (sig, 0, 1);
2094           else
2095             show_keyserver_url (sig, 0, 2);
2096
2097           if ((opt.verify_options & VERIFY_SHOW_NOTATIONS))
2098             show_notation
2099               (sig, 0, 1,
2100                (((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)
2101                 + ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0)));
2102           else
2103             show_notation (sig, 0, 2, 0);
2104         }
2105
2106       /* For good signatures print the VALIDSIG status line.  */
2107       if (!rc && is_status_enabled ())
2108         {
2109           if (pk)
2110             {
2111               byte array[MAX_FINGERPRINT_LEN], *p;
2112               char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
2113               size_t i, n;
2114
2115               bufp = buf;
2116               fingerprint_from_pk (pk, array, &n);
2117               p = array;
2118               for(i=0; i < n ; i++, p++, bufp += 2)
2119                 sprintf (bufp, "%02X", *p );
2120               /* TODO: Replace the reserved '0' in the field below
2121                  with bits for status flags (policy url, notation,
2122                  etc.).  Remember to make the buffer larger to match! */
2123               sprintf (bufp, " %s %lu %lu %d 0 %d %d %02X ",
2124                        strtimestamp( sig->timestamp ),
2125                        (ulong)sig->timestamp,(ulong)sig->expiredate,
2126                        sig->version,sig->pubkey_algo,sig->digest_algo,
2127                        sig->sig_class);
2128               bufp = bufp + strlen (bufp);
2129               if (!pk->flags.primary)
2130                 fingerprint_from_pk (mainpk, array, &n);
2131               p = array;
2132               for (i=0; i < n ; i++, p++, bufp += 2)
2133                 sprintf(bufp, "%02X", *p );
2134               write_status_text (STATUS_VALIDSIG, buf);
2135             }
2136         }
2137
2138       /* For good signatures compute and print the trust information.
2139          Note that in the Tofu trust model this may ask the user on
2140          how to resolve a conflict.  */
2141       if (!rc)
2142         {
2143           if ((opt.verify_options & VERIFY_PKA_LOOKUPS))
2144             pka_uri_from_sig (c, sig); /* Make sure PKA info is available. */
2145           rc = check_signatures_trust (c->ctrl, sig);
2146         }
2147
2148       /* Print extra information about the signature.  */
2149       if (sig->flags.expired)
2150         {
2151           log_info (_("Signature expired %s\n"), asctimestamp(sig->expiredate));
2152           rc = GPG_ERR_GENERAL; /* Need a better error here?  */
2153         }
2154       else if (sig->expiredate)
2155         log_info (_("Signature expires %s\n"), asctimestamp(sig->expiredate));
2156
2157       if (opt.verbose)
2158         {
2159           char pkstrbuf[PUBKEY_STRING_SIZE];
2160
2161           if (pk)
2162             pubkey_string (pk, pkstrbuf, sizeof pkstrbuf);
2163           else
2164             *pkstrbuf = 0;
2165
2166           log_info (_("%s signature, digest algorithm %s%s%s\n"),
2167                     sig->sig_class==0x00?_("binary"):
2168                     sig->sig_class==0x01?_("textmode"):_("unknown"),
2169                     gcry_md_algo_name (sig->digest_algo),
2170                     *pkstrbuf?_(", key algorithm "):"", pkstrbuf);
2171         }
2172
2173       /* Print final warnings.  */
2174       if (!rc && !c->signed_data.used)
2175         {
2176           /* Signature is basically good but we test whether the
2177              deprecated command
2178                gpg --verify FILE.sig
2179              was used instead of
2180                gpg --verify FILE.sig FILE
2181              to verify a detached signature.  If we figure out that a
2182              data file with a matching name exists, we print a warning.
2183
2184              The problem is that the first form would also verify a
2185              standard signature.  This behavior could be used to
2186              create a made up .sig file for a tarball by creating a
2187              standard signature from a valid detached signature packet
2188              (for example from a signed git tag).  Then replace the
2189              sig file on the FTP server along with a changed tarball.
2190              Using the first form the verify command would correctly
2191              verify the signature but don't even consider the tarball.  */
2192           kbnode_t n;
2193           char *dfile;
2194
2195           dfile = get_matching_datafile (c->sigfilename);
2196           if (dfile)
2197             {
2198               for (n = c->list; n; n = n->next)
2199                 if (n->pkt->pkttype != PKT_SIGNATURE)
2200                   break;
2201               if (n)
2202                 {
2203                   /* Not only signature packets in the tree thus this
2204                      is not a detached signature.  */
2205                   log_info (_("WARNING: not a detached signature; "
2206                               "file '%s' was NOT verified!\n"), dfile);
2207                 }
2208               xfree (dfile);
2209             }
2210         }
2211
2212       release_kbnode( keyblock );
2213       if (rc)
2214         g10_errors_seen = 1;
2215       if (opt.batch && rc)
2216         g10_exit (1);
2217     }
2218   else
2219     {
2220       char buf[50];
2221
2222       snprintf (buf, sizeof buf, "%08lX%08lX %d %d %02x %lu %d",
2223                 (ulong)sig->keyid[0], (ulong)sig->keyid[1],
2224                 sig->pubkey_algo, sig->digest_algo,
2225                 sig->sig_class, (ulong)sig->timestamp, rc);
2226       write_status_text (STATUS_ERRSIG, buf);
2227       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
2228         {
2229           buf[16] = 0;
2230           write_status_text (STATUS_NO_PUBKEY, buf);
2231         }
2232       if (gpg_err_code (rc) != GPG_ERR_NOT_PROCESSED)
2233         log_error (_("Can't check signature: %s\n"), gpg_strerror (rc));
2234     }
2235
2236   return rc;
2237 }
2238
2239
2240 /*
2241  * Process the tree which starts at node
2242  */
2243 static void
2244 proc_tree (CTX c, kbnode_t node)
2245 {
2246   kbnode_t n1;
2247   int rc;
2248
2249   if (opt.list_packets || opt.list_only)
2250     return;
2251
2252   /* We must skip our special plaintext marker packets here because
2253      they may be the root packet.  These packets are only used in
2254      addional checks and skipping them here doesn't matter.  */
2255   while (node
2256          && node->pkt->pkttype == PKT_GPG_CONTROL
2257           && node->pkt->pkt.gpg_control->control == CTRLPKT_PLAINTEXT_MARK)
2258     {
2259       node = node->next;
2260     }
2261   if (!node)
2262     return;
2263
2264   c->trustletter = ' ';
2265   if (node->pkt->pkttype == PKT_PUBLIC_KEY
2266       || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2267     {
2268       merge_keys_and_selfsig (node);
2269       list_node (c, node);
2270     }
2271   else if (node->pkt->pkttype == PKT_SECRET_KEY)
2272     {
2273       merge_keys_and_selfsig (node);
2274       list_node (c, node);
2275     }
2276   else if (node->pkt->pkttype == PKT_ONEPASS_SIG)
2277     {
2278       /* Check all signatures.  */
2279       if (!c->any.data)
2280         {
2281           int use_textmode = 0;
2282
2283           free_md_filter_context (&c->mfx);
2284           /* Prepare to create all requested message digests.  */
2285           rc = gcry_md_open (&c->mfx.md, 0, 0);
2286           if (rc)
2287             goto hash_err;
2288
2289           /* Fixme: why looking for the signature packet and not the
2290              one-pass packet?  */
2291           for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2292             gcry_md_enable (c->mfx.md, n1->pkt->pkt.signature->digest_algo);
2293
2294           if (n1 && n1->pkt->pkt.onepass_sig->sig_class == 0x01)
2295             use_textmode = 1;
2296
2297           /* Ask for file and hash it. */
2298           if (c->sigs_only)
2299             {
2300               if (c->signed_data.used && c->signed_data.data_fd != -1)
2301                 rc = hash_datafile_by_fd (c->mfx.md, NULL,
2302                                           c->signed_data.data_fd,
2303                                           use_textmode);
2304               else
2305                 rc = hash_datafiles (c->mfx.md, NULL,
2306                                      c->signed_data.data_names,
2307                                      c->sigfilename,
2308                                      use_textmode);
2309             }
2310           else
2311             {
2312               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2313                                               iobuf_get_real_fname (c->iobuf),
2314                                               use_textmode);
2315             }
2316
2317         hash_err:
2318           if (rc)
2319             {
2320               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2321               return;
2322             }
2323         }
2324       else if (c->signed_data.used)
2325         {
2326           log_error (_("not a detached signature\n"));
2327           return;
2328         }
2329
2330       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2331         check_sig_and_print (c, n1);
2332
2333     }
2334   else if (node->pkt->pkttype == PKT_GPG_CONTROL
2335            && node->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
2336     {
2337       /* Clear text signed message.  */
2338       if (!c->any.data)
2339         {
2340           log_error ("cleartext signature without data\n");
2341           return;
2342         }
2343       else if (c->signed_data.used)
2344         {
2345           log_error (_("not a detached signature\n"));
2346           return;
2347         }
2348
2349       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2350         check_sig_and_print (c, n1);
2351
2352     }
2353   else if (node->pkt->pkttype == PKT_SIGNATURE)
2354     {
2355       PKT_signature *sig = node->pkt->pkt.signature;
2356       int multiple_ok = 1;
2357
2358       n1 = find_next_kbnode (node, PKT_SIGNATURE);
2359       if (n1)
2360         {
2361           byte class = sig->sig_class;
2362           byte hash  = sig->digest_algo;
2363
2364           for (; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2365             {
2366               /* We can't currently handle multiple signatures of
2367                  different classes or digests (we'd pretty much have
2368                  to run a different hash context for each), but if
2369                  they are all the same, make an exception. */
2370               if (n1->pkt->pkt.signature->sig_class != class
2371                   || n1->pkt->pkt.signature->digest_algo != hash)
2372                 {
2373                   multiple_ok = 0;
2374                   log_info (_("WARNING: multiple signatures detected.  "
2375                               "Only the first will be checked.\n"));
2376                   break;
2377                 }
2378             }
2379         }
2380
2381       if (sig->sig_class != 0x00 && sig->sig_class != 0x01)
2382         {
2383           log_info(_("standalone signature of class 0x%02x\n"), sig->sig_class);
2384         }
2385       else if (!c->any.data)
2386         {
2387           /* Detached signature */
2388           free_md_filter_context (&c->mfx);
2389           rc = gcry_md_open (&c->mfx.md, sig->digest_algo, 0);
2390           if (rc)
2391             goto detached_hash_err;
2392
2393           if (RFC2440 || RFC4880)
2394             ; /* Strict RFC mode.  */
2395           else if (sig->digest_algo == DIGEST_ALGO_SHA1
2396                    && sig->pubkey_algo == PUBKEY_ALGO_DSA
2397                    && sig->sig_class == 0x01)
2398             {
2399               /* Enable a workaround for a pgp5 bug when the detached
2400                * signature has been created in textmode.  */
2401               rc = gcry_md_open (&c->mfx.md2, sig->digest_algo, 0);
2402               if (rc)
2403                 goto detached_hash_err;
2404             }
2405
2406           /* Here we used to have another hack to work around a pgp
2407            * 2 bug: It worked by not using the textmode for detached
2408            * signatures; this would let the first signature check
2409            * (on md) fail but the second one (on md2), which adds an
2410            * extra CR would then have produced the "correct" hash.
2411            * This is very, very ugly hack but it may haved help in
2412            * some cases (and break others).
2413            *     c->mfx.md2? 0 :(sig->sig_class == 0x01)
2414            */
2415
2416           if (DBG_HASHING)
2417             {
2418               gcry_md_debug (c->mfx.md, "verify");
2419               if (c->mfx.md2)
2420                 gcry_md_debug (c->mfx.md2, "verify2");
2421             }
2422
2423           if (c->sigs_only)
2424             {
2425               if (c->signed_data.used && c->signed_data.data_fd != -1)
2426                 rc = hash_datafile_by_fd (c->mfx.md, c->mfx.md2,
2427                                           c->signed_data.data_fd,
2428                                           (sig->sig_class == 0x01));
2429               else
2430                 rc = hash_datafiles (c->mfx.md, c->mfx.md2,
2431                                      c->signed_data.data_names,
2432                                      c->sigfilename,
2433                                      (sig->sig_class == 0x01));
2434             }
2435           else
2436             {
2437               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2438                                               iobuf_get_real_fname(c->iobuf),
2439                                               (sig->sig_class == 0x01));
2440             }
2441
2442         detached_hash_err:
2443           if (rc)
2444             {
2445               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2446               return;
2447             }
2448         }
2449       else if (c->signed_data.used)
2450         {
2451           log_error (_("not a detached signature\n"));
2452           return;
2453         }
2454       else if (!opt.quiet)
2455         log_info (_("old style (PGP 2.x) signature\n"));
2456
2457       if (multiple_ok)
2458         {
2459           for (n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2460             check_sig_and_print (c, n1);
2461         }
2462       else
2463         check_sig_and_print (c, node);
2464
2465     }
2466   else
2467     {
2468       dump_kbnode (c->list);
2469       log_error ("invalid root packet detected in proc_tree()\n");
2470       dump_kbnode (node);
2471     }
2472 }