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