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