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