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