Fixed problem with PGP2 style signatures and mutilple plaintext data
[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;  /* Stop here as one-pass signature packets are not
684                        expected.  */
685           }
686         else if(n->pkt->pkttype==PKT_SIGNATURE)
687           {
688             /* For the SIG+LITERAL case that PGP used to use. */
689             md_enable( c->mfx.md, n->pkt->pkt.signature->digest_algo );
690             any=1;
691           }
692       }
693
694     if( !any && !opt.skip_verify )
695       {
696         /* This is for the old GPG LITERAL+SIG case.  It's not legal
697            according to 2440, so hopefully it won't come up that
698            often.  There is no good way to specify what algorithms to
699            use in that case, so these three are the historical
700            answer. */
701         md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
702         md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
703         md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
704       }
705     if( opt.pgp2_workarounds && only_md5 && !opt.skip_verify ) {
706         /* This is a kludge to work around a bug in pgp2.  It does only
707          * catch those mails which are armored.  To catch the non-armored
708          * pgp mails we could see whether there is the signature packet
709          * in front of the plaintext.  If someone needs this, send me a patch.
710          */
711         c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0);
712     }
713     if ( DBG_HASHING ) {
714         md_start_debug( c->mfx.md, "verify" );
715         if ( c->mfx.md2  )
716             md_start_debug( c->mfx.md2, "verify2" );
717     }
718     if ( c->pipemode.op == 'B' )
719         rc = handle_plaintext( pt, &c->mfx, 1, 0 );
720     else {
721         rc = handle_plaintext( pt, &c->mfx, c->sigs_only, clearsig );
722         if( rc == G10ERR_CREATE_FILE && !c->sigs_only) {
723             /* can't write output but we hash it anyway to
724              * check the signature */
725             rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
726         }
727     }
728     if( rc )
729         log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
730     free_packet(pkt);
731     c->last_was_session_key = 0;
732
733     /* We add a marker control packet instead of the plaintext packet.
734      * This is so that we can later detect invalid packet sequences.
735      */
736     n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
737     if (c->list)
738         add_kbnode (c->list, n);
739     else 
740         c->list = n;
741 }
742
743
744 static int
745 proc_compressed_cb( IOBUF a, void *info )
746 {
747     return proc_signature_packets( info, a, ((CTX)info)->signed_data,
748                                             ((CTX)info)->sigfilename );
749 }
750
751 static int
752 proc_encrypt_cb( IOBUF a, void *info )
753 {
754     return proc_encryption_packets( info, a );
755 }
756
757 static void
758 proc_compressed( CTX c, PACKET *pkt )
759 {
760     PKT_compressed *zd = pkt->pkt.compressed;
761     int rc;
762
763     /*printf("zip: compressed data packet\n");*/
764     if( c->sigs_only )
765         rc = handle_compressed( c, zd, proc_compressed_cb, c );
766     else if( c->encrypt_only )
767         rc = handle_compressed( c, zd, proc_encrypt_cb, c );
768     else
769         rc = handle_compressed( c, zd, NULL, NULL );
770     if( rc )
771         log_error("uncompressing failed: %s\n", g10_errstr(rc));
772     free_packet(pkt);
773     c->last_was_session_key = 0;
774 }
775
776 /****************
777  * check the signature
778  * Returns: 0 = valid signature or an error code
779  */
780 static int
781 do_check_sig( CTX c, KBNODE node, int *is_selfsig,
782               int *is_expkey, int *is_revkey )
783 {
784     PKT_signature *sig;
785     MD_HANDLE md = NULL, md2 = NULL;
786     int algo, rc;
787
788     assert( node->pkt->pkttype == PKT_SIGNATURE );
789     if( is_selfsig )
790         *is_selfsig = 0;
791     sig = node->pkt->pkt.signature;
792
793     algo = sig->digest_algo;
794     if( (rc=check_digest_algo(algo)) )
795         return rc;
796
797     if( sig->sig_class == 0x00 ) {
798         if( c->mfx.md )
799             md = md_copy( c->mfx.md );
800         else /* detached signature */
801             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
802     }
803     else if( sig->sig_class == 0x01 ) {
804         /* how do we know that we have to hash the (already hashed) text
805          * in canonical mode ??? (calculating both modes???) */
806         if( c->mfx.md ) {
807             md = md_copy( c->mfx.md );
808             if( c->mfx.md2 )
809                md2 = md_copy( c->mfx.md2 );
810         }
811         else { /* detached signature */
812           log_debug("Do we really need this here?");
813             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
814             md2 = md_open( 0, 0 );
815         }
816     }
817     else if( (sig->sig_class&~3) == 0x10
818              || sig->sig_class == 0x18
819              || sig->sig_class == 0x1f
820              || sig->sig_class == 0x20
821              || sig->sig_class == 0x28
822              || sig->sig_class == 0x30  ) { 
823         if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
824             || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
825             return check_key_signature( c->list, node, is_selfsig );
826         }
827         else if( sig->sig_class == 0x20 ) {
828             log_info(_("standalone revocation - "
829                        "use \"gpg --import\" to apply\n"));
830             return G10ERR_NOT_PROCESSED;
831         }
832         else {
833             log_error("invalid root packet for sigclass %02x\n",
834                                                         sig->sig_class);
835             return G10ERR_SIG_CLASS;
836         }
837     }
838     else
839         return G10ERR_SIG_CLASS;
840     rc = signature_check2( sig, md, NULL, is_expkey, is_revkey, NULL );
841     if( rc == G10ERR_BAD_SIGN && md2 )
842         rc = signature_check2( sig, md2, NULL, is_expkey, is_revkey, NULL );
843     md_close(md);
844     md_close(md2);
845
846     return rc;
847 }
848
849
850 static void
851 print_userid( PACKET *pkt )
852 {
853     if( !pkt )
854         BUG();
855     if( pkt->pkttype != PKT_USER_ID ) {
856         printf("ERROR: unexpected packet type %d", pkt->pkttype );
857         return;
858     }
859     if( opt.with_colons )
860       {
861         if(pkt->pkt.user_id->attrib_data)
862           printf("%u %lu",
863                  pkt->pkt.user_id->numattribs,
864                  pkt->pkt.user_id->attrib_len);
865         else
866           print_string( stdout,  pkt->pkt.user_id->name,
867                         pkt->pkt.user_id->len, ':');
868       }
869     else
870         print_utf8_string( stdout,  pkt->pkt.user_id->name,
871                                      pkt->pkt.user_id->len );
872 }
873
874
875 /****************
876  * List the certificate in a user friendly way
877  */
878
879 static void
880 list_node( CTX c, KBNODE node )
881 {
882     int any=0;
883     int mainkey;
884
885     if( !node )
886         ;
887     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
888              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
889         PKT_public_key *pk = node->pkt->pkt.public_key;
890
891         if( opt.with_colons )
892           {
893             u32 keyid[2];
894             keyid_from_pk( pk, keyid );
895             if( mainkey )
896               c->trustletter = opt.fast_list_mode?
897                 0 : get_validity_info( pk, NULL );
898             printf("%s:", mainkey? "pub":"sub" );
899             if( c->trustletter )
900               putchar( c->trustletter );
901             printf(":%u:%d:%08lX%08lX:%s:%s::",
902                    nbits_from_pk( pk ),
903                    pk->pubkey_algo,
904                    (ulong)keyid[0],(ulong)keyid[1],
905                    colon_datestr_from_pk( pk ),
906                    colon_strtime (pk->expiredate) );
907             if( mainkey && !opt.fast_list_mode )
908               putchar( get_ownertrust_info (pk) );
909             putchar(':');
910             if( node->next && node->next->pkt->pkttype == PKT_RING_TRUST) {
911               putchar('\n'); any=1;
912               if( opt.fingerprint )
913                 print_fingerprint( pk, NULL, 0 );
914               printf("rtv:1:%u:\n",
915                      node->next->pkt->pkt.ring_trust->trustval );
916             }
917           }
918         else
919           printf("%s  %4u%c/%s %s%s",
920                  mainkey? "pub":"sub", nbits_from_pk( pk ),
921                  pubkey_letter( pk->pubkey_algo ), keystr_from_pk( pk ),
922                  datestr_from_pk( pk ), mainkey?" ":"");
923
924         if( mainkey ) {
925             /* and now list all userids with their signatures */
926             for( node = node->next; node; node = node->next ) {
927                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
928                     if( !any ) {
929                         if( node->pkt->pkt.signature->sig_class == 0x20 )
930                             puts("[revoked]");
931                         else
932                             putchar('\n');
933                         any = 1;
934                     }
935                     list_node(c,  node );
936                 }
937                 else if( node->pkt->pkttype == PKT_USER_ID ) {
938                     if( any ) {
939                         if( opt.with_colons )
940                             printf("%s:::::::::",
941                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
942                         else
943                             printf( "uid%*s", 28, "" );
944                     }
945                     print_userid( node->pkt );
946                     if( opt.with_colons )
947                         putchar(':');
948                     putchar('\n');
949                     if( opt.fingerprint && !any )
950                         print_fingerprint( pk, NULL, 0 );
951                     if( node->next
952                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
953                         printf("rtv:2:%u:\n",
954                                  node->next->pkt->pkt.ring_trust->trustval );
955                     }
956                     any=1;
957                 }
958                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
959                     if( !any ) {
960                         putchar('\n');
961                         any = 1;
962                     }
963                     list_node(c,  node );
964                 }
965             }
966         }
967         else
968           {
969             /* of subkey */
970             if( pk->is_revoked )
971               {
972                 printf(" [");
973                 printf(_("revoked: %s"),revokestr_from_pk(pk));
974                 printf("]");
975               }
976             else if( pk->expiredate )
977               {
978                 printf(" [");
979                 printf(_("expires: %s"),expirestr_from_pk(pk));
980                 printf("]");
981               }
982           }
983
984         if( !any )
985             putchar('\n');
986         if( !mainkey && opt.fingerprint > 1 )
987             print_fingerprint( pk, NULL, 0 );
988     }
989     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
990              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
991         PKT_secret_key *sk = node->pkt->pkt.secret_key;
992
993         if( opt.with_colons )
994           {
995             u32 keyid[2];
996             keyid_from_sk( sk, keyid );
997             printf("%s::%u:%d:%08lX%08lX:%s:%s:::",
998                    mainkey? "sec":"ssb",
999                    nbits_from_sk( sk ),
1000                    sk->pubkey_algo,
1001                    (ulong)keyid[0],(ulong)keyid[1],
1002                    colon_datestr_from_sk( sk ),
1003                    colon_strtime (sk->expiredate)
1004                    /* fixme: add LID */ );
1005           }
1006         else
1007           printf("%s  %4u%c/%s %s ", mainkey? "sec":"ssb",
1008                  nbits_from_sk( sk ), pubkey_letter( sk->pubkey_algo ),
1009                  keystr_from_sk( sk ), datestr_from_sk( sk ));
1010         if( mainkey ) {
1011             /* and now list all userids with their signatures */
1012             for( node = node->next; node; node = node->next ) {
1013                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
1014                     if( !any ) {
1015                         if( node->pkt->pkt.signature->sig_class == 0x20 )
1016                             puts("[revoked]");
1017                         else
1018                             putchar('\n');
1019                         any = 1;
1020                     }
1021                     list_node(c,  node );
1022                 }
1023                 else if( node->pkt->pkttype == PKT_USER_ID ) {
1024                     if( any ) {
1025                         if( opt.with_colons )
1026                             printf("%s:::::::::",
1027                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
1028                         else
1029                             printf( "uid%*s", 28, "" );
1030                     }
1031                     print_userid( node->pkt );
1032                     if( opt.with_colons )
1033                         putchar(':');
1034                     putchar('\n');
1035                     if( opt.fingerprint && !any )
1036                         print_fingerprint( NULL, sk, 0 );
1037                     any=1;
1038                 }
1039                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1040                     if( !any ) {
1041                         putchar('\n');
1042                         any = 1;
1043                     }
1044                     list_node(c,  node );
1045                 }
1046             }
1047         }
1048         if( !any )
1049             putchar('\n');
1050         if( !mainkey && opt.fingerprint > 1 )
1051             print_fingerprint( NULL, sk, 0 );
1052     }
1053     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
1054         PKT_signature *sig = node->pkt->pkt.signature;
1055         int is_selfsig = 0;
1056         int rc2=0;
1057         size_t n;
1058         char *p;
1059         int sigrc = ' ';
1060
1061         if( !opt.verbose )
1062             return;
1063
1064         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
1065             fputs("rev", stdout);
1066         else
1067             fputs("sig", stdout);
1068         if( opt.check_sigs ) {
1069             fflush(stdout);
1070             switch( (rc2=do_check_sig( c, node, &is_selfsig, NULL, NULL )) ) {
1071               case 0:                  sigrc = '!'; break;
1072               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
1073               case G10ERR_NO_PUBKEY: 
1074               case G10ERR_UNU_PUBKEY:  sigrc = '?'; break;
1075               default:                 sigrc = '%'; break;
1076             }
1077         }
1078         else {  /* check whether this is a self signature */
1079             u32 keyid[2];
1080
1081             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
1082                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
1083                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
1084                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
1085                 else
1086                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
1087
1088                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
1089                     is_selfsig = 1;
1090             }
1091         }
1092         if( opt.with_colons ) {
1093             putchar(':');
1094             if( sigrc != ' ' )
1095                 putchar(sigrc);
1096             printf("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1097                    (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1098                    colon_datestr_from_sig(sig),
1099                    colon_expirestr_from_sig(sig));
1100
1101             if(sig->trust_depth || sig->trust_value)
1102               printf("%d %d",sig->trust_depth,sig->trust_value);
1103             printf(":");
1104
1105             if(sig->trust_regexp)
1106               print_string(stdout,sig->trust_regexp,
1107                            strlen(sig->trust_regexp),':');
1108             printf(":");
1109         }
1110         else
1111           printf("%c       %s %s   ",
1112                  sigrc, keystr(sig->keyid), datestr_from_sig(sig));
1113         if( sigrc == '%' )
1114             printf("[%s] ", g10_errstr(rc2) );
1115         else if( sigrc == '?' )
1116             ;
1117         else if( is_selfsig ) {
1118             if( opt.with_colons )
1119                 putchar(':');
1120             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
1121             if( opt.with_colons )
1122                 putchar(':');
1123         }
1124         else if( !opt.fast_list_mode ) {
1125             p = get_user_id( sig->keyid, &n );
1126             print_string( stdout, p, n, opt.with_colons );
1127             xfree(p);
1128         }
1129         if( opt.with_colons )
1130             printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1131         putchar('\n');
1132     }
1133     else
1134         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
1135 }
1136
1137
1138
1139 int
1140 proc_packets( void *anchor, IOBUF a )
1141 {
1142     int rc;
1143     CTX c = xmalloc_clear( sizeof *c );
1144
1145     c->anchor = anchor;
1146     rc = do_proc_packets( c, a );
1147     xfree( c );
1148     return rc;
1149 }
1150
1151
1152
1153 int
1154 proc_signature_packets( void *anchor, IOBUF a,
1155                         STRLIST signedfiles, const char *sigfilename )
1156 {
1157     CTX c = xmalloc_clear( sizeof *c );
1158     int rc;
1159
1160     c->anchor = anchor;
1161     c->sigs_only = 1;
1162     c->signed_data = signedfiles;
1163     c->sigfilename = sigfilename;
1164     rc = do_proc_packets( c, a );
1165
1166     /* If we have not encountered any signature we print an error
1167        messages, send a NODATA status back and return an error code.
1168        Using log_error is required because verify_files does not check
1169        error codes for each file but we want to terminate the process
1170        with an error. */ 
1171     if (!rc && !c->any_sig_seen)
1172       {
1173         write_status_text (STATUS_NODATA, "4");
1174         log_error (_("no signature found\n"));
1175         rc = G10ERR_NO_DATA;
1176       }
1177     xfree( c );
1178     return rc;
1179 }
1180
1181 int
1182 proc_encryption_packets( void *anchor, IOBUF a )
1183 {
1184     CTX c = xmalloc_clear( sizeof *c );
1185     int rc;
1186
1187     c->anchor = anchor;
1188     c->encrypt_only = 1;
1189     rc = do_proc_packets( c, a );
1190     xfree( c );
1191     return rc;
1192 }
1193
1194
1195 int
1196 do_proc_packets( CTX c, IOBUF a )
1197 {
1198     PACKET *pkt = xmalloc( sizeof *pkt );
1199     int rc=0;
1200     int any_data=0;
1201     int newpkt;
1202
1203     c->iobuf = a;
1204     init_packet(pkt);
1205     while( (rc=parse_packet(a, pkt)) != -1 ) {
1206         any_data = 1;
1207         if( rc ) {
1208             free_packet(pkt);
1209             /* stop processing when an invalid packet has been encountered
1210              * but don't do so when we are doing a --list-packets. */
1211             if( rc == G10ERR_INVALID_PACKET && opt.list_packets != 2 )
1212                 break;
1213             continue;
1214         }
1215         newpkt = -1;
1216         if( opt.list_packets ) {
1217             switch( pkt->pkttype ) {
1218               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1219               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1220               case PKT_ENCRYPTED:
1221               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1222               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1223               default: newpkt = 0; break;
1224             }
1225         }
1226         else if( c->sigs_only ) {
1227             switch( pkt->pkttype ) {
1228               case PKT_PUBLIC_KEY:
1229               case PKT_SECRET_KEY:
1230               case PKT_USER_ID:
1231               case PKT_SYMKEY_ENC:
1232               case PKT_PUBKEY_ENC:
1233               case PKT_ENCRYPTED:
1234               case PKT_ENCRYPTED_MDC:
1235                 write_status_text( STATUS_UNEXPECTED, "0" );
1236                 rc = G10ERR_UNEXPECTED;
1237                 goto leave;
1238               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1239               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1240               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1241               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1242               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1243               default: newpkt = 0; break;
1244             }
1245         }
1246         else if( c->encrypt_only ) {
1247             switch( pkt->pkttype ) {
1248               case PKT_PUBLIC_KEY:
1249               case PKT_SECRET_KEY:
1250               case PKT_USER_ID:
1251                 write_status_text( STATUS_UNEXPECTED, "0" );
1252                 rc = G10ERR_UNEXPECTED;
1253                 goto leave;
1254               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1255               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1256               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1257               case PKT_ENCRYPTED:
1258               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1259               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1260               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1261               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1262               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1263               default: newpkt = 0; break;
1264             }
1265         }
1266         else {
1267             switch( pkt->pkttype ) {
1268               case PKT_PUBLIC_KEY:
1269               case PKT_SECRET_KEY:
1270                 release_list( c );
1271                 c->list = new_kbnode( pkt );
1272                 newpkt = 1;
1273                 break;
1274               case PKT_PUBLIC_SUBKEY:
1275               case PKT_SECRET_SUBKEY:
1276                 newpkt = add_subkey( c, pkt );
1277                 break;
1278               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1279               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1280               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1281               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1282               case PKT_ENCRYPTED:
1283               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1284               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1285               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1286               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1287               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1288               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1289               default: newpkt = 0; break;
1290             }
1291         }
1292         /* This is a very ugly construct and frankly, I don't remember why
1293          * I used it.  Adding the MDC check here is a hack.
1294          * The right solution is to initiate another context for encrypted
1295          * packet and not to reuse the current one ...  It works right
1296          * when there is a compression packet inbetween which adds just
1297          * an extra layer.
1298          * Hmmm: Rewrite this whole module here?? 
1299          */
1300         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1301             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
1302
1303         if( newpkt == -1 )
1304             ;
1305         else if( newpkt ) {
1306             pkt = xmalloc( sizeof *pkt );
1307             init_packet(pkt);
1308         }
1309         else
1310             free_packet(pkt);
1311         if ( c->pipemode.stop_now ) {
1312             /* we won't get an EOF in pipemode, so we have to 
1313              * break the loop here */ 
1314             rc = -1;
1315             break;
1316         }
1317     }
1318     if( rc == G10ERR_INVALID_PACKET )
1319         write_status_text( STATUS_NODATA, "3" );
1320     if( any_data )
1321         rc = 0;
1322     else if( rc == -1 )
1323         write_status_text( STATUS_NODATA, "2" );
1324
1325
1326   leave:
1327     release_list( c );
1328     xfree(c->dek);
1329     free_packet( pkt );
1330     xfree( pkt );
1331     free_md_filter_context( &c->mfx );
1332     return rc;
1333 }
1334
1335
1336 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1337    of the notation data. */
1338 static pka_info_t *
1339 get_pka_address (PKT_signature *sig)
1340 {
1341   const unsigned char *p;
1342   size_t len, n1, n2;
1343   int seq = 0;
1344   pka_info_t *pka = NULL;
1345
1346   while ((p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION,
1347                                &len, &seq, NULL)))
1348     {
1349       if (len < 8)
1350         continue; /* Notation packet is too short. */
1351       n1 = (p[4]<<8)|p[5];
1352       n2 = (p[6]<<8)|p[7];
1353       if (8 + n1 + n2 != len)
1354         continue; /* Length fields of notation packet are inconsistent. */
1355       p += 8;
1356       if (n1 != 21 || memcmp (p, "pka-address@gnupg.org", 21))
1357         continue; /* Not the notation we want. */
1358       p += n1;
1359       if (n2 < 3)
1360         continue; /* Impossible email address. */
1361
1362       if (pka)
1363         break; /* For now we only use the first valid PKA notation. In
1364                   future we might want to keep additional PKA
1365                   notations in a linked list. */
1366
1367       pka = xmalloc (sizeof *pka + n2);
1368       pka->valid = 0;
1369       pka->checked = 0;
1370       pka->uri = NULL;
1371       memcpy (pka->email, p, n2);
1372       pka->email[n2] = 0;
1373
1374       if (!is_valid_mailbox (pka->email))
1375         {
1376           /* We don't accept invalid mail addresses. */
1377           xfree (pka);
1378           pka = NULL;
1379         }
1380     }
1381
1382   return pka;
1383 }
1384
1385
1386 /* Return the URI from a DNS PKA record.  If this record has already
1387    be retrieved for the signature we merely return it; if not we go
1388    out and try to get that DNS record. */
1389 static const char *
1390 pka_uri_from_sig (PKT_signature *sig)
1391 {
1392   if (!sig->flags.pka_tried)
1393     {
1394       assert (!sig->pka_info);
1395       sig->flags.pka_tried = 1;
1396       sig->pka_info = get_pka_address (sig);
1397       if (sig->pka_info && opt.allow_pka_lookup)
1398         {
1399           char *uri;
1400
1401           uri = get_pka_info (sig->pka_info->email, sig->pka_info->fpr);
1402           if (uri)
1403             {
1404               sig->pka_info->valid = 1;
1405               if (!*uri)
1406                 xfree (uri);
1407               else
1408                 sig->pka_info->uri = uri;
1409             }
1410         }
1411     }
1412   return sig->pka_info? sig->pka_info->uri : NULL;
1413 }
1414
1415
1416 static int
1417 check_sig_and_print( CTX c, KBNODE node )
1418 {
1419     PKT_signature *sig = node->pkt->pkt.signature;
1420     const char *astr;
1421     int rc, is_expkey=0, is_revkey=0;
1422
1423     if( opt.skip_verify ) {
1424         log_info(_("signature verification suppressed\n"));
1425         return 0;
1426     }
1427
1428     /* It is not in all cases possible to check multiple signatures:
1429      * PGP 2 (which is also allowed by OpenPGP), does use the packet
1430      * sequence: sig+data,  OpenPGP does use onepas+data=sig and GnuPG
1431      * sometimes uses (because I did'nt read the specs right) data+sig.
1432      * Because it is possible to create multiple signatures with
1433      * different packet sequence (e.g. data+sig and sig+data) it might
1434      * not be possible to get it right:  let's say we have:
1435      * data+sig, sig+data,sig+data and we have not yet encountered the last
1436      * data, we could also see this a one data with 2 signatures and then 
1437      * data+sig.
1438      * To protect against this we check that all signatures follow
1439      * without any intermediate packets.  Note, that we won't get this
1440      * error when we use onepass packets or cleartext signatures because
1441      * we reset the list every time
1442      *
1443      * FIXME: Now that we have these marker packets, we should create a 
1444      * real grammar and check against this.
1445      */
1446     {
1447         KBNODE n;
1448         int n_sig = 0;
1449         int n_plaintext = 0;
1450         int sig_seen, onepass_seen;
1451
1452         for (n=c->list; n; n=n->next ) 
1453           {
1454             if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1455               n_sig++;
1456             else if (n->pkt->pkttype == PKT_GPG_CONTROL
1457                   && (n->pkt->pkt.gpg_control->control
1458                       == CTRLPKT_PLAINTEXT_MARK) )
1459               n_plaintext++;
1460           }
1461         
1462         for (sig_seen=onepass_seen=0,n=c->list; n; n=n->next ) 
1463           {
1464             if (n->pkt->pkttype == PKT_ONEPASS_SIG) 
1465               {
1466                 onepass_seen++;
1467               }
1468             else if (n->pkt->pkttype == PKT_GPG_CONTROL
1469                      && (n->pkt->pkt.gpg_control->control
1470                          == CTRLPKT_CLEARSIGN_START) ) 
1471               {
1472                 onepass_seen++; /* Handle the same way as a onepass. */
1473               }
1474             else if ( (sig_seen && n->pkt->pkttype != PKT_SIGNATURE) ) 
1475               {
1476                 log_error(_("can't handle these multiple signatures\n"));
1477                 return 0;
1478               }
1479             else if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1480               {
1481                 sig_seen = 1;
1482               }
1483             else if (n_sig > 1 && !sig_seen && !onepass_seen 
1484                      && n->pkt->pkttype == PKT_GPG_CONTROL
1485                      && (n->pkt->pkt.gpg_control->control
1486                             == CTRLPKT_PLAINTEXT_MARK) )
1487               {
1488                 /* Plaintext before signatures but no onepass
1489                    signature packets. */
1490                 log_error(_("can't handle these multiple signatures\n"));
1491                 return 0;
1492               }
1493             else if (n_plaintext > 1 && !sig_seen && !onepass_seen 
1494                      && n->pkt->pkttype == PKT_GPG_CONTROL
1495                      && (n->pkt->pkt.gpg_control->control
1496                             == CTRLPKT_PLAINTEXT_MARK) )
1497               {
1498                 /* More than one plaintext before a signature but no
1499                    onepass packets.  */
1500                 log_error(_("can't handle this ambiguous signed data\n"));
1501                 return 0;
1502               }
1503           }
1504     }
1505
1506     astr = pubkey_algo_to_string( sig->pubkey_algo );
1507     if(keystrlen()>8)
1508       {
1509         log_info(_("Signature made %s\n"),asctimestamp(sig->timestamp));
1510         log_info(_("               using %s key %s\n"),
1511                  astr? astr: "?",keystr(sig->keyid));
1512       }
1513     else
1514       log_info(_("Signature made %s using %s key ID %s\n"),
1515                asctimestamp(sig->timestamp), astr? astr: "?",
1516                keystr(sig->keyid));
1517
1518     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1519
1520     /* If the key isn't found, check for a preferred keyserver */
1521
1522     if(rc==G10ERR_NO_PUBKEY && sig->flags.pref_ks)
1523       {
1524         const byte *p;
1525         int seq=0;
1526         size_t n;
1527
1528         while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1529           {
1530             /* According to my favorite copy editor, in English
1531                grammar, you say "at" if the key is located on a web
1532                page, but "from" if it is located on a keyserver.  I'm
1533                not going to even try to make two strings here :) */
1534             log_info(_("Key available at: ") );
1535             print_utf8_string( log_stream(), p, n );
1536             putc( '\n', log_stream() );
1537
1538             if(opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1539                && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1540               {
1541                 struct keyserver_spec *spec;
1542
1543                 spec=parse_preferred_keyserver(sig);
1544                 if(spec)
1545                   {
1546                     int res;
1547
1548                     glo_ctrl.in_auto_key_retrieve++;
1549                     res=keyserver_import_keyid(sig->keyid,spec);
1550                     glo_ctrl.in_auto_key_retrieve--;
1551                     if(!res)
1552                       rc=do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1553                     free_keyserver_spec(spec);
1554
1555                     if(!rc)
1556                       break;
1557                   }
1558               }
1559           }
1560       }
1561
1562     /* If the preferred keyserver thing above didn't work, our second
1563        try is to use the URI from a DNS PKA record. */
1564     if ( rc == G10ERR_NO_PUBKEY 
1565          && opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1566          && opt.keyserver_options.options&KEYSERVER_HONOR_PKA_RECORD)
1567       {
1568         const char *uri = pka_uri_from_sig (sig);
1569         
1570         if (uri)
1571           {
1572             /* FIXME: We might want to locate the key using the
1573                fingerprint instead of the keyid. */
1574             int res;
1575             struct keyserver_spec *spec;
1576             
1577             spec = parse_keyserver_uri (uri, 1, NULL, 0);
1578             if (spec)
1579               {
1580                 glo_ctrl.in_auto_key_retrieve++;
1581                 res = keyserver_import_keyid (sig->keyid, spec);
1582                 glo_ctrl.in_auto_key_retrieve--;
1583                 free_keyserver_spec (spec);
1584                 if (!res)
1585                   rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1586               }
1587           }
1588       }
1589
1590     /* If the preferred keyserver thing above didn't work and we got
1591        no information from the DNS PKA, this is a third try. */
1592
1593     if( rc == G10ERR_NO_PUBKEY && opt.keyserver
1594         && opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
1595       {
1596         int res;
1597
1598         glo_ctrl.in_auto_key_retrieve++;
1599         res=keyserver_import_keyid ( sig->keyid, opt.keyserver );
1600         glo_ctrl.in_auto_key_retrieve--;
1601         if(!res)
1602           rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1603       }
1604
1605     if( !rc || rc == G10ERR_BAD_SIGN ) {
1606         KBNODE un, keyblock;
1607         int count=0, statno;
1608         char keyid_str[50];
1609         PKT_public_key *pk=NULL;
1610
1611         if(rc)
1612           statno=STATUS_BADSIG;
1613         else if(sig->flags.expired)
1614           statno=STATUS_EXPSIG;
1615         else if(is_expkey)
1616           statno=STATUS_EXPKEYSIG;
1617         else if(is_revkey)
1618           statno=STATUS_REVKEYSIG;
1619         else
1620           statno=STATUS_GOODSIG;
1621
1622         keyblock = get_pubkeyblock( sig->keyid );
1623
1624         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1625                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1626
1627         /* find and print the primary user ID */
1628         for( un=keyblock; un; un = un->next ) {
1629             char *p;
1630             int valid;
1631             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1632               {
1633                 pk=un->pkt->pkt.public_key;
1634                 continue;
1635               }
1636             if( un->pkt->pkttype != PKT_USER_ID )
1637                 continue;
1638             if ( !un->pkt->pkt.user_id->created )
1639                 continue;
1640             if ( un->pkt->pkt.user_id->is_revoked )
1641                 continue;
1642             if ( un->pkt->pkt.user_id->is_expired )
1643                 continue;
1644             if ( !un->pkt->pkt.user_id->is_primary )
1645                 continue;
1646             /* We want the textual primary user ID here */
1647             if ( un->pkt->pkt.user_id->attrib_data )
1648                 continue;
1649
1650             assert(pk);
1651
1652             /* Get it before we print anything to avoid interrupting
1653                the output with the "please do a --check-trustdb"
1654                line. */
1655             valid=get_validity(pk,un->pkt->pkt.user_id);
1656
1657             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1658             write_status_text_and_buffer (statno, keyid_str,
1659                                           un->pkt->pkt.user_id->name,
1660                                           un->pkt->pkt.user_id->len, 
1661                                           -1 );
1662
1663             p=utf8_to_native(un->pkt->pkt.user_id->name,
1664                              un->pkt->pkt.user_id->len,0);
1665
1666             if(rc)
1667               log_info(_("BAD signature from \"%s\""),p);
1668             else if(sig->flags.expired)
1669               log_info(_("Expired signature from \"%s\""),p);
1670             else
1671               log_info(_("Good signature from \"%s\""),p);
1672
1673             xfree(p);
1674
1675             if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1676               fprintf(log_stream()," [%s]\n",trust_value_to_string(valid));
1677             else
1678               fputs("\n", log_stream() );
1679             count++;
1680         }
1681         if( !count ) {  /* just in case that we have no valid textual
1682                            userid */
1683             char *p;
1684
1685             /* Try for an invalid textual userid */
1686             for( un=keyblock; un; un = un->next ) {
1687                 if( un->pkt->pkttype == PKT_USER_ID &&
1688                     !un->pkt->pkt.user_id->attrib_data )
1689                     break;
1690             }
1691
1692             /* Try for any userid at all */
1693             if(!un) {
1694                 for( un=keyblock; un; un = un->next ) {
1695                     if( un->pkt->pkttype == PKT_USER_ID )
1696                         break;
1697                 }
1698             }
1699
1700             if (opt.trust_model==TM_ALWAYS || !un)
1701                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1702
1703             write_status_text_and_buffer (statno, keyid_str,
1704                                           un? un->pkt->pkt.user_id->name:"[?]",
1705                                           un? un->pkt->pkt.user_id->len:3, 
1706                                           -1 );
1707
1708             if(un)
1709               p=utf8_to_native(un->pkt->pkt.user_id->name,
1710                                un->pkt->pkt.user_id->len,0);
1711             else
1712               p=xstrdup("[?]");
1713
1714             if(rc)
1715               log_info(_("BAD signature from \"%s\""),p);
1716             else if(sig->flags.expired)
1717               log_info(_("Expired signature from \"%s\""),p);
1718             else
1719               log_info(_("Good signature from \"%s\""),p);
1720             if (opt.trust_model!=TM_ALWAYS && un)
1721               {
1722                 putc(' ', log_stream() );
1723                 fputs(_("[uncertain]"), log_stream() );
1724               }
1725             fputs("\n", log_stream() );
1726         }
1727
1728         /* If we have a good signature and already printed 
1729          * the primary user ID, print all the other user IDs */
1730         if ( count && !rc ) {
1731             char *p;
1732             for( un=keyblock; un; un = un->next ) {
1733                 if( un->pkt->pkttype != PKT_USER_ID )
1734                     continue;
1735                 if((un->pkt->pkt.user_id->is_revoked
1736                     || un->pkt->pkt.user_id->is_expired)
1737                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1738                   continue;
1739                 /* Only skip textual primaries */
1740                 if ( un->pkt->pkt.user_id->is_primary &&
1741                      !un->pkt->pkt.user_id->attrib_data )
1742                     continue;
1743
1744                 if(un->pkt->pkt.user_id->attrib_data)
1745                   {
1746                     dump_attribs(un->pkt->pkt.user_id,pk,NULL);
1747
1748                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1749                       show_photos(un->pkt->pkt.user_id->attribs,
1750                                   un->pkt->pkt.user_id->numattribs,pk,NULL);
1751                   }
1752
1753                 p=utf8_to_native(un->pkt->pkt.user_id->name,
1754                                  un->pkt->pkt.user_id->len,0);
1755                 log_info(_("                aka \"%s\""),p);
1756                 xfree(p);
1757
1758                 if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1759                   {
1760                     const char *valid;
1761                     if(un->pkt->pkt.user_id->is_revoked)
1762                       valid=_("revoked");
1763                     else if(un->pkt->pkt.user_id->is_expired)
1764                       valid=_("expired");
1765                     else
1766                       valid=trust_value_to_string(get_validity(pk,
1767                                                                un->pkt->
1768                                                                pkt.user_id));
1769                     fprintf(log_stream()," [%s]\n",valid);
1770                   }
1771                 else
1772                   fputs("\n", log_stream() );
1773             }
1774         }
1775         release_kbnode( keyblock );
1776
1777         if( !rc )
1778           {
1779             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1780               show_policy_url(sig,0,1);
1781             else
1782               show_policy_url(sig,0,2);
1783
1784             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1785               show_keyserver_url(sig,0,1);
1786             else
1787               show_keyserver_url(sig,0,2);
1788
1789             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1790               show_notation(sig,0,1,
1791                         ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
1792                         ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
1793             else
1794               show_notation(sig,0,2,0);
1795           }
1796
1797         if( !rc && is_status_enabled() ) {
1798             /* print a status response with the fingerprint */
1799             PKT_public_key *vpk = xmalloc_clear( sizeof *vpk );
1800
1801             if( !get_pubkey( vpk, sig->keyid ) ) {
1802                 byte array[MAX_FINGERPRINT_LEN], *p;
1803                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1804                 size_t i, n;
1805
1806                 bufp = buf;
1807                 fingerprint_from_pk( vpk, array, &n );
1808                 p = array;
1809                 for(i=0; i < n ; i++, p++, bufp += 2)
1810                     sprintf(bufp, "%02X", *p );
1811                 /* TODO: Replace the reserved '0' in the field below
1812                    with bits for status flags (policy url, notation,
1813                    etc.).  Remember to make the buffer larger to
1814                    match! */
1815                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1816                         strtimestamp( sig->timestamp ),
1817                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1818                         sig->version,sig->pubkey_algo,sig->digest_algo,
1819                         sig->sig_class);
1820                 bufp = bufp + strlen (bufp);
1821                 if (!vpk->is_primary) {
1822                    u32 akid[2];
1823  
1824                    akid[0] = vpk->main_keyid[0];
1825                    akid[1] = vpk->main_keyid[1];
1826                    free_public_key (vpk);
1827                    vpk = xmalloc_clear( sizeof *vpk );
1828                    if (get_pubkey (vpk, akid)) {
1829                      /* impossible error, we simply return a zeroed out fpr */
1830                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1831                      memset (array, 0, n);
1832                    }
1833                    else
1834                      fingerprint_from_pk( vpk, array, &n );
1835                 }
1836                 p = array;
1837                 for(i=0; i < n ; i++, p++, bufp += 2)
1838                     sprintf(bufp, "%02X", *p );
1839                 write_status_text( STATUS_VALIDSIG, buf );
1840             }
1841             free_public_key( vpk );
1842         }
1843
1844         if (!rc)
1845           {
1846             pka_uri_from_sig (sig); /* Make sure PKA info is available. */
1847             rc = check_signatures_trust( sig );
1848           }
1849
1850         if(sig->flags.expired)
1851           {
1852             log_info(_("Signature expired %s\n"),
1853                      asctimestamp(sig->expiredate));
1854             rc=G10ERR_GENERAL; /* need a better error here? */
1855           }
1856         else if(sig->expiredate)
1857           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1858
1859         if(opt.verbose)
1860           log_info(_("%s signature, digest algorithm %s\n"),
1861                    sig->sig_class==0x00?_("binary"):
1862                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1863                    digest_algo_to_string(sig->digest_algo));
1864
1865         if( rc )
1866             g10_errors_seen = 1;
1867         if( opt.batch && rc )
1868             g10_exit(1);
1869     }
1870     else {
1871         char buf[50];
1872         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1873                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1874                      sig->pubkey_algo, sig->digest_algo,
1875                      sig->sig_class, (ulong)sig->timestamp, rc );
1876         write_status_text( STATUS_ERRSIG, buf );
1877         if( rc == G10ERR_NO_PUBKEY ) {
1878             buf[16] = 0;
1879             write_status_text( STATUS_NO_PUBKEY, buf );
1880         }
1881         if( rc != G10ERR_NOT_PROCESSED )
1882             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1883     }
1884     return rc;
1885 }
1886
1887
1888 /****************
1889  * Process the tree which starts at node
1890  */
1891 static void
1892 proc_tree( CTX c, KBNODE node )
1893 {
1894     KBNODE n1;
1895     int rc;
1896
1897     if( opt.list_packets || opt.list_only )
1898         return;
1899
1900     /* we must skip our special plaintext marker packets here becuase
1901        they may be the root packet.  These packets are only used in
1902        addionla checks and skipping them here doesn't matter */
1903     while ( node
1904             && node->pkt->pkttype == PKT_GPG_CONTROL
1905             && node->pkt->pkt.gpg_control->control
1906                          == CTRLPKT_PLAINTEXT_MARK ) {
1907         node = node->next;
1908     }
1909     if (!node)
1910         return;
1911
1912     c->trustletter = ' ';
1913     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1914         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1915         merge_keys_and_selfsig( node );
1916         list_node( c, node );
1917     }
1918     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1919         merge_keys_and_selfsig( node );
1920         list_node( c, node );
1921     }
1922     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1923         /* check all signatures */
1924         if( !c->have_data ) {
1925             free_md_filter_context( &c->mfx );
1926             /* prepare to create all requested message digests */
1927             c->mfx.md = md_open(0, 0);
1928
1929             /* fixme: why looking for the signature packet and not 1passpacket*/
1930             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1931                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1932             }
1933             /* ask for file and hash it */
1934             if( c->sigs_only ) {
1935                 rc = hash_datafiles( c->mfx.md, NULL,
1936                                      c->signed_data, c->sigfilename,
1937                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1938             }
1939             else {
1940                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1941                                                 iobuf_get_real_fname(c->iobuf),
1942                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1943             }
1944             if( rc ) {
1945                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1946                 return;
1947             }
1948         }
1949         else if ( c->signed_data ) {
1950             log_error (_("not a detached signature\n") );
1951             return;
1952         }
1953
1954         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1955             check_sig_and_print( c, n1 );
1956     }
1957     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1958              && node->pkt->pkt.gpg_control->control
1959                 == CTRLPKT_CLEARSIGN_START ) {
1960         /* clear text signed message */
1961         if( !c->have_data ) {
1962             log_error("cleartext signature without data\n" );
1963             return;
1964         }
1965         else if ( c->signed_data ) {
1966             log_error (_("not a detached signature\n") );
1967             return;
1968         }
1969         
1970         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1971             check_sig_and_print( c, n1 );
1972     }
1973     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1974         PKT_signature *sig = node->pkt->pkt.signature;
1975         int multiple_ok=1;
1976
1977         n1=find_next_kbnode(node, PKT_SIGNATURE);
1978         if(n1)
1979           {
1980             byte class=sig->sig_class;
1981             byte hash=sig->digest_algo;
1982
1983             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1984               {
1985                 /* We can't currently handle multiple signatures of
1986                    different classes or digests (we'd pretty much have
1987                    to run a different hash context for each), but if
1988                    they are all the same, make an exception. */
1989                 if(n1->pkt->pkt.signature->sig_class!=class
1990                    || n1->pkt->pkt.signature->digest_algo!=hash)
1991                   {
1992                     multiple_ok=0;
1993                     log_info(_("WARNING: multiple signatures detected.  "
1994                                "Only the first will be checked.\n"));
1995                     break;
1996                   }
1997               }
1998           }
1999
2000         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
2001             log_info(_("standalone signature of class 0x%02x\n"),
2002                                                     sig->sig_class);
2003         else if( !c->have_data ) {
2004             /* detached signature */
2005             free_md_filter_context( &c->mfx );
2006             c->mfx.md = md_open(sig->digest_algo, 0);
2007             if( !opt.pgp2_workarounds )
2008                 ;
2009             else if( sig->digest_algo == DIGEST_ALGO_MD5
2010                      && is_RSA( sig->pubkey_algo ) ) {
2011                 /* enable a workaround for a pgp2 bug */
2012                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
2013             }
2014             else if( sig->digest_algo == DIGEST_ALGO_SHA1
2015                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
2016                      && sig->sig_class == 0x01 ) {
2017                 /* enable the workaround also for pgp5 when the detached
2018                  * signature has been created in textmode */
2019                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
2020             }
2021 #if 0 /* workaround disabled */
2022             /* Here we have another hack to work around a pgp 2 bug
2023              * It works by not using the textmode for detached signatures;
2024              * this will let the first signature check (on md) fail
2025              * but the second one (on md2) which adds an extra CR should
2026              * then produce the "correct" hash.  This is very, very ugly
2027              * hack but it may help in some cases (and break others)
2028              */
2029                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
2030 #endif
2031             if ( DBG_HASHING ) {
2032                 md_start_debug( c->mfx.md, "verify" );
2033                 if ( c->mfx.md2  )
2034                     md_start_debug( c->mfx.md2, "verify2" );
2035             }
2036             if( c->sigs_only ) {
2037                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
2038                                      c->signed_data, c->sigfilename,
2039                                      (sig->sig_class == 0x01) );
2040             }
2041             else {
2042                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
2043                                                 iobuf_get_real_fname(c->iobuf),
2044                                                 (sig->sig_class == 0x01) );
2045             }
2046             if( rc ) {
2047                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2048                 return;
2049             }
2050         }
2051         else if ( c->signed_data ) {
2052             log_error (_("not a detached signature\n") );
2053             return;
2054         }
2055         else if ( c->pipemode.op == 'B' )
2056             ; /* this is a detached signature trough the pipemode handler */
2057         else if (!opt.quiet)
2058             log_info(_("old style (PGP 2.x) signature\n"));
2059
2060         if(multiple_ok)
2061           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
2062             check_sig_and_print( c, n1 );
2063         else
2064           check_sig_and_print( c, node );
2065     }
2066     else {
2067         dump_kbnode (c->list);
2068         log_error(_("invalid root packet detected in proc_tree()\n"));
2069         dump_kbnode (node);
2070     }
2071 }