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