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