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