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