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