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