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