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