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