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