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