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