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