* mainproc.c (proc_compressed): "Uncompressed" is not a valid compression
[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     xfree( c );
1167     return rc;
1168 }
1169
1170 int
1171 proc_encryption_packets( void *anchor, IOBUF a )
1172 {
1173     CTX c = xmalloc_clear( sizeof *c );
1174     int rc;
1175
1176     c->anchor = anchor;
1177     c->encrypt_only = 1;
1178     rc = do_proc_packets( c, a );
1179     xfree( c );
1180     return rc;
1181 }
1182
1183
1184 int
1185 do_proc_packets( CTX c, IOBUF a )
1186 {
1187     PACKET *pkt = xmalloc( sizeof *pkt );
1188     int rc=0;
1189     int any_data=0;
1190     int newpkt;
1191
1192     c->iobuf = a;
1193     init_packet(pkt);
1194     while( (rc=parse_packet(a, pkt)) != -1 ) {
1195         any_data = 1;
1196         if( rc ) {
1197             free_packet(pkt);
1198             /* stop processing when an invalid packet has been encountered
1199              * but don't do so when we are doing a --list-packets. */
1200             if( rc == G10ERR_INVALID_PACKET && opt.list_packets != 2 )
1201                 break;
1202             continue;
1203         }
1204         newpkt = -1;
1205         if( opt.list_packets ) {
1206             switch( pkt->pkttype ) {
1207               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1208               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1209               case PKT_ENCRYPTED:
1210               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1211               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1212               default: newpkt = 0; break;
1213             }
1214         }
1215         else if( c->sigs_only ) {
1216             switch( pkt->pkttype ) {
1217               case PKT_PUBLIC_KEY:
1218               case PKT_SECRET_KEY:
1219               case PKT_USER_ID:
1220               case PKT_SYMKEY_ENC:
1221               case PKT_PUBKEY_ENC:
1222               case PKT_ENCRYPTED:
1223               case PKT_ENCRYPTED_MDC:
1224                 write_status_text( STATUS_UNEXPECTED, "0" );
1225                 rc = G10ERR_UNEXPECTED;
1226                 goto leave;
1227               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1228               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1229               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1230               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1231               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1232               default: newpkt = 0; break;
1233             }
1234         }
1235         else if( c->encrypt_only ) {
1236             switch( pkt->pkttype ) {
1237               case PKT_PUBLIC_KEY:
1238               case PKT_SECRET_KEY:
1239               case PKT_USER_ID:
1240                 write_status_text( STATUS_UNEXPECTED, "0" );
1241                 rc = G10ERR_UNEXPECTED;
1242                 goto leave;
1243               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1244               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1245               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1246               case PKT_ENCRYPTED:
1247               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1248               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1249               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1250               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1251               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1252               default: newpkt = 0; break;
1253             }
1254         }
1255         else {
1256             switch( pkt->pkttype ) {
1257               case PKT_PUBLIC_KEY:
1258               case PKT_SECRET_KEY:
1259                 release_list( c );
1260                 c->list = new_kbnode( pkt );
1261                 newpkt = 1;
1262                 break;
1263               case PKT_PUBLIC_SUBKEY:
1264               case PKT_SECRET_SUBKEY:
1265                 newpkt = add_subkey( c, pkt );
1266                 break;
1267               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1268               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1269               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1270               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1271               case PKT_ENCRYPTED:
1272               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1273               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1274               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1275               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1276               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1277               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1278               default: newpkt = 0; break;
1279             }
1280         }
1281         /* This is a very ugly construct and frankly, I don't remember why
1282          * I used it.  Adding the MDC check here is a hack.
1283          * The right solution is to initiate another context for encrypted
1284          * packet and not to reuse the current one ...  It works right
1285          * when there is a compression packet inbetween which adds just
1286          * an extra layer.
1287          * Hmmm: Rewrite this whole module here?? 
1288          */
1289         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1290             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
1291
1292         if( newpkt == -1 )
1293             ;
1294         else if( newpkt ) {
1295             pkt = xmalloc( sizeof *pkt );
1296             init_packet(pkt);
1297         }
1298         else
1299             free_packet(pkt);
1300         if ( c->pipemode.stop_now ) {
1301             /* we won't get an EOF in pipemode, so we have to 
1302              * break the loop here */ 
1303             rc = -1;
1304             break;
1305         }
1306     }
1307     if( rc == G10ERR_INVALID_PACKET )
1308         write_status_text( STATUS_NODATA, "3" );
1309     if( any_data )
1310         rc = 0;
1311     else if( rc == -1 )
1312         write_status_text( STATUS_NODATA, "2" );
1313
1314
1315   leave:
1316     release_list( c );
1317     xfree(c->dek);
1318     free_packet( pkt );
1319     xfree( pkt );
1320     free_md_filter_context( &c->mfx );
1321     return rc;
1322 }
1323
1324
1325 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1326    of the notation data. */
1327 static pka_info_t *
1328 get_pka_address (PKT_signature *sig)
1329 {
1330   const unsigned char *p;
1331   size_t len, n1, n2;
1332   int seq = 0;
1333   pka_info_t *pka = NULL;
1334
1335   while ((p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION,
1336                                &len, &seq, NULL)))
1337     {
1338       if (len < 8)
1339         continue; /* Notation packet is too short. */
1340       n1 = (p[4]<<8)|p[5];
1341       n2 = (p[6]<<8)|p[7];
1342       if (8 + n1 + n2 != len)
1343         continue; /* Length fields of notation packet are inconsistent. */
1344       p += 8;
1345       if (n1 != 21 || memcmp (p, "pka-address@gnupg.org", 21))
1346         continue; /* Not the notation we want. */
1347       p += n1;
1348       if (n2 < 3)
1349         continue; /* Impossible email address. */
1350
1351       if (pka)
1352         break; /* For now we only use the first valid PKA notation. In
1353                   future we might want to keep additional PKA
1354                   notations in a linked list. */
1355
1356       pka = xmalloc (sizeof *pka + n2);
1357       pka->valid = 0;
1358       pka->checked = 0;
1359       pka->uri = NULL;
1360       memcpy (pka->email, p, n2);
1361       pka->email[n2] = 0;
1362
1363       if (!is_valid_mailbox (pka->email))
1364         {
1365           /* We don't accept invalid mail addresses. */
1366           xfree (pka);
1367           pka = NULL;
1368         }
1369     }
1370
1371   return pka;
1372 }
1373
1374
1375 /* Return the URI from a DNS PKA record.  If this record has already
1376    be retrieved for the signature we merely return it; if not we go
1377    out and try to get that DNS record. */
1378 static const char *
1379 pka_uri_from_sig (PKT_signature *sig)
1380 {
1381   if (!sig->flags.pka_tried)
1382     {
1383       assert (!sig->pka_info);
1384       sig->flags.pka_tried = 1;
1385       sig->pka_info = get_pka_address (sig);
1386       if (sig->pka_info && opt.allow_pka_lookup)
1387         {
1388           char *uri;
1389
1390           uri = get_pka_info (sig->pka_info->email, sig->pka_info->fpr);
1391           if (uri)
1392             {
1393               sig->pka_info->valid = 1;
1394               if (!*uri)
1395                 xfree (uri);
1396               else
1397                 sig->pka_info->uri = uri;
1398             }
1399         }
1400     }
1401   return sig->pka_info? sig->pka_info->uri : NULL;
1402 }
1403
1404
1405 static int
1406 check_sig_and_print( CTX c, KBNODE node )
1407 {
1408   PKT_signature *sig = node->pkt->pkt.signature;
1409   const char *astr;
1410   int rc, is_expkey=0, is_revkey=0;
1411
1412   if (opt.skip_verify)
1413     {
1414       log_info(_("signature verification suppressed\n"));
1415       return 0;
1416     }
1417
1418   /* Check that the message composition is valid.
1419
1420      Per RFC-2440bis (-15) allowed:
1421
1422      S{1,n}           -- detached signature.
1423      S{1,n} P         -- old style PGP2 signature
1424      O{1,n} P S{1,n}  -- standard OpenPGP signature.
1425      C P S{1,n}       -- cleartext signature.
1426
1427         
1428           O = One-Pass Signature packet.
1429           S = Signature packet.
1430           P = OpenPGP Message packet (Encrypted | Compressed | Literal)
1431                  (Note that the current rfc2440bis draft also allows
1432                   for a signed message but that does not work as it
1433                   introduces ambiguities.)
1434               We keep track of these packages using the marker packet
1435               CTRLPKT_PLAINTEXT_MARK.
1436           C = Marker packet for cleartext signatures.
1437
1438      We reject all other messages.
1439      
1440      Actually we are calling this too often, i.e. for verification of
1441      each message but better have some duplicate work than to silently
1442      introduce a bug here.
1443   */
1444   {
1445     KBNODE n;
1446     int n_onepass, n_sig;
1447
1448     log_debug ("checking signature packet composition\n");
1449     dump_kbnode (c->list);
1450
1451     n = c->list;
1452     assert (n);
1453     if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1454       {
1455         /* This is either "S{1,n}" case (detached signature) or
1456            "S{1,n} P" (old style PGP2 signature). */
1457         for (n = n->next; n; n = n->next)
1458           if (n->pkt->pkttype != PKT_SIGNATURE)
1459             break;
1460         if (!n)
1461           ; /* Okay, this is a detached signature.  */
1462         else if (n->pkt->pkttype == PKT_GPG_CONTROL
1463                  && (n->pkt->pkt.gpg_control->control
1464                      == CTRLPKT_PLAINTEXT_MARK) )
1465           {
1466             if (n->next)
1467               goto ambiguous;  /* We only allow one P packet. */
1468           }
1469         else
1470           goto ambiguous;
1471       }
1472     else if (n->pkt->pkttype == PKT_ONEPASS_SIG) 
1473       {
1474         /* This is the "O{1,n} P S{1,n}" case (standard signature). */
1475         for (n_onepass=1, n = n->next;
1476              n && n->pkt->pkttype == PKT_ONEPASS_SIG; n = n->next)
1477           n_onepass++;
1478         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1479                     && (n->pkt->pkt.gpg_control->control
1480                         == CTRLPKT_PLAINTEXT_MARK)))
1481           goto ambiguous;
1482         for (n_sig=0, n = n->next;
1483              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1484           n_sig++;
1485         if (n || !n_sig)
1486           goto ambiguous;
1487         if (n_onepass != n_sig)
1488           {
1489             log_info ("number of one-pass packets does not match "
1490                       "number of signature packets\n");
1491             goto ambiguous;
1492           }
1493       }
1494     else if (n->pkt->pkttype == PKT_GPG_CONTROL
1495              && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
1496       {
1497         /* This is the "C P S{1,n}" case (clear text signature). */
1498         n = n->next;
1499         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1500                     && (n->pkt->pkt.gpg_control->control
1501                         == CTRLPKT_PLAINTEXT_MARK)))
1502           goto ambiguous;
1503         for (n_sig=0, n = n->next;
1504              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1505           n_sig++;
1506         if (n || !n_sig)
1507           goto ambiguous;
1508       }
1509     else 
1510       {
1511       ambiguous:
1512         log_error(_("can't handle this ambiguous signature data\n"));
1513         return 0;
1514       }
1515
1516   }
1517
1518   /* (Indendation below not yet changed to GNU style.) */
1519
1520     astr = pubkey_algo_to_string( sig->pubkey_algo );
1521     if(keystrlen()>8)
1522       {
1523         log_info(_("Signature made %s\n"),asctimestamp(sig->timestamp));
1524         log_info(_("               using %s key %s\n"),
1525                  astr? astr: "?",keystr(sig->keyid));
1526       }
1527     else
1528       log_info(_("Signature made %s using %s key ID %s\n"),
1529                asctimestamp(sig->timestamp), astr? astr: "?",
1530                keystr(sig->keyid));
1531
1532     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1533
1534     /* If the key isn't found, check for a preferred keyserver */
1535
1536     if(rc==G10ERR_NO_PUBKEY && sig->flags.pref_ks)
1537       {
1538         const byte *p;
1539         int seq=0;
1540         size_t n;
1541
1542         while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1543           {
1544             /* According to my favorite copy editor, in English
1545                grammar, you say "at" if the key is located on a web
1546                page, but "from" if it is located on a keyserver.  I'm
1547                not going to even try to make two strings here :) */
1548             log_info(_("Key available at: ") );
1549             print_utf8_string( log_stream(), p, n );
1550             putc( '\n', log_stream() );
1551
1552             if(opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1553                && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1554               {
1555                 struct keyserver_spec *spec;
1556
1557                 spec=parse_preferred_keyserver(sig);
1558                 if(spec)
1559                   {
1560                     int res;
1561
1562                     glo_ctrl.in_auto_key_retrieve++;
1563                     res=keyserver_import_keyid(sig->keyid,spec);
1564                     glo_ctrl.in_auto_key_retrieve--;
1565                     if(!res)
1566                       rc=do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1567                     free_keyserver_spec(spec);
1568
1569                     if(!rc)
1570                       break;
1571                   }
1572               }
1573           }
1574       }
1575
1576     /* If the preferred keyserver thing above didn't work, our second
1577        try is to use the URI from a DNS PKA record. */
1578     if ( rc == G10ERR_NO_PUBKEY 
1579          && opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1580          && opt.keyserver_options.options&KEYSERVER_HONOR_PKA_RECORD)
1581       {
1582         const char *uri = pka_uri_from_sig (sig);
1583         
1584         if (uri)
1585           {
1586             /* FIXME: We might want to locate the key using the
1587                fingerprint instead of the keyid. */
1588             int res;
1589             struct keyserver_spec *spec;
1590             
1591             spec = parse_keyserver_uri (uri, 1, NULL, 0);
1592             if (spec)
1593               {
1594                 glo_ctrl.in_auto_key_retrieve++;
1595                 res = keyserver_import_keyid (sig->keyid, spec);
1596                 glo_ctrl.in_auto_key_retrieve--;
1597                 free_keyserver_spec (spec);
1598                 if (!res)
1599                   rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1600               }
1601           }
1602       }
1603
1604     /* If the preferred keyserver thing above didn't work and we got
1605        no information from the DNS PKA, this is a third try. */
1606
1607     if( rc == G10ERR_NO_PUBKEY && opt.keyserver
1608         && opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
1609       {
1610         int res;
1611
1612         glo_ctrl.in_auto_key_retrieve++;
1613         res=keyserver_import_keyid ( sig->keyid, opt.keyserver );
1614         glo_ctrl.in_auto_key_retrieve--;
1615         if(!res)
1616           rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1617       }
1618
1619     if( !rc || rc == G10ERR_BAD_SIGN ) {
1620         KBNODE un, keyblock;
1621         int count=0, statno;
1622         char keyid_str[50];
1623         PKT_public_key *pk=NULL;
1624
1625         if(rc)
1626           statno=STATUS_BADSIG;
1627         else if(sig->flags.expired)
1628           statno=STATUS_EXPSIG;
1629         else if(is_expkey)
1630           statno=STATUS_EXPKEYSIG;
1631         else if(is_revkey)
1632           statno=STATUS_REVKEYSIG;
1633         else
1634           statno=STATUS_GOODSIG;
1635
1636         keyblock = get_pubkeyblock( sig->keyid );
1637
1638         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1639                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1640
1641         /* find and print the primary user ID */
1642         for( un=keyblock; un; un = un->next ) {
1643             char *p;
1644             int valid;
1645             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1646               {
1647                 pk=un->pkt->pkt.public_key;
1648                 continue;
1649               }
1650             if( un->pkt->pkttype != PKT_USER_ID )
1651                 continue;
1652             if ( !un->pkt->pkt.user_id->created )
1653                 continue;
1654             if ( un->pkt->pkt.user_id->is_revoked )
1655                 continue;
1656             if ( un->pkt->pkt.user_id->is_expired )
1657                 continue;
1658             if ( !un->pkt->pkt.user_id->is_primary )
1659                 continue;
1660             /* We want the textual primary user ID here */
1661             if ( un->pkt->pkt.user_id->attrib_data )
1662                 continue;
1663
1664             assert(pk);
1665
1666             /* Get it before we print anything to avoid interrupting
1667                the output with the "please do a --check-trustdb"
1668                line. */
1669             valid=get_validity(pk,un->pkt->pkt.user_id);
1670
1671             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1672             write_status_text_and_buffer (statno, keyid_str,
1673                                           un->pkt->pkt.user_id->name,
1674                                           un->pkt->pkt.user_id->len, 
1675                                           -1 );
1676
1677             p=utf8_to_native(un->pkt->pkt.user_id->name,
1678                              un->pkt->pkt.user_id->len,0);
1679
1680             if(rc)
1681               log_info(_("BAD signature from \"%s\""),p);
1682             else if(sig->flags.expired)
1683               log_info(_("Expired signature from \"%s\""),p);
1684             else
1685               log_info(_("Good signature from \"%s\""),p);
1686
1687             xfree(p);
1688
1689             if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1690               fprintf(log_stream()," [%s]\n",trust_value_to_string(valid));
1691             else
1692               fputs("\n", log_stream() );
1693             count++;
1694         }
1695         if( !count ) {  /* just in case that we have no valid textual
1696                            userid */
1697             char *p;
1698
1699             /* Try for an invalid textual userid */
1700             for( un=keyblock; un; un = un->next ) {
1701                 if( un->pkt->pkttype == PKT_USER_ID &&
1702                     !un->pkt->pkt.user_id->attrib_data )
1703                     break;
1704             }
1705
1706             /* Try for any userid at all */
1707             if(!un) {
1708                 for( un=keyblock; un; un = un->next ) {
1709                     if( un->pkt->pkttype == PKT_USER_ID )
1710                         break;
1711                 }
1712             }
1713
1714             if (opt.trust_model==TM_ALWAYS || !un)
1715                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1716
1717             write_status_text_and_buffer (statno, keyid_str,
1718                                           un? un->pkt->pkt.user_id->name:"[?]",
1719                                           un? un->pkt->pkt.user_id->len:3, 
1720                                           -1 );
1721
1722             if(un)
1723               p=utf8_to_native(un->pkt->pkt.user_id->name,
1724                                un->pkt->pkt.user_id->len,0);
1725             else
1726               p=xstrdup("[?]");
1727
1728             if(rc)
1729               log_info(_("BAD signature from \"%s\""),p);
1730             else if(sig->flags.expired)
1731               log_info(_("Expired signature from \"%s\""),p);
1732             else
1733               log_info(_("Good signature from \"%s\""),p);
1734             if (opt.trust_model!=TM_ALWAYS && un)
1735               {
1736                 putc(' ', log_stream() );
1737                 fputs(_("[uncertain]"), log_stream() );
1738               }
1739             fputs("\n", log_stream() );
1740         }
1741
1742         /* If we have a good signature and already printed 
1743          * the primary user ID, print all the other user IDs */
1744         if ( count && !rc ) {
1745             char *p;
1746             for( un=keyblock; un; un = un->next ) {
1747                 if( un->pkt->pkttype != PKT_USER_ID )
1748                     continue;
1749                 if((un->pkt->pkt.user_id->is_revoked
1750                     || un->pkt->pkt.user_id->is_expired)
1751                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1752                   continue;
1753                 /* Only skip textual primaries */
1754                 if ( un->pkt->pkt.user_id->is_primary &&
1755                      !un->pkt->pkt.user_id->attrib_data )
1756                     continue;
1757
1758                 if(un->pkt->pkt.user_id->attrib_data)
1759                   {
1760                     dump_attribs(un->pkt->pkt.user_id,pk,NULL);
1761
1762                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1763                       show_photos(un->pkt->pkt.user_id->attribs,
1764                                   un->pkt->pkt.user_id->numattribs,pk,NULL);
1765                   }
1766
1767                 p=utf8_to_native(un->pkt->pkt.user_id->name,
1768                                  un->pkt->pkt.user_id->len,0);
1769                 log_info(_("                aka \"%s\""),p);
1770                 xfree(p);
1771
1772                 if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1773                   {
1774                     const char *valid;
1775                     if(un->pkt->pkt.user_id->is_revoked)
1776                       valid=_("revoked");
1777                     else if(un->pkt->pkt.user_id->is_expired)
1778                       valid=_("expired");
1779                     else
1780                       valid=trust_value_to_string(get_validity(pk,
1781                                                                un->pkt->
1782                                                                pkt.user_id));
1783                     fprintf(log_stream()," [%s]\n",valid);
1784                   }
1785                 else
1786                   fputs("\n", log_stream() );
1787             }
1788         }
1789         release_kbnode( keyblock );
1790
1791         if( !rc )
1792           {
1793             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1794               show_policy_url(sig,0,1);
1795             else
1796               show_policy_url(sig,0,2);
1797
1798             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1799               show_keyserver_url(sig,0,1);
1800             else
1801               show_keyserver_url(sig,0,2);
1802
1803             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1804               show_notation(sig,0,1,
1805                         ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
1806                         ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
1807             else
1808               show_notation(sig,0,2,0);
1809           }
1810
1811         if( !rc && is_status_enabled() ) {
1812             /* print a status response with the fingerprint */
1813             PKT_public_key *vpk = xmalloc_clear( sizeof *vpk );
1814
1815             if( !get_pubkey( vpk, sig->keyid ) ) {
1816                 byte array[MAX_FINGERPRINT_LEN], *p;
1817                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1818                 size_t i, n;
1819
1820                 bufp = buf;
1821                 fingerprint_from_pk( vpk, array, &n );
1822                 p = array;
1823                 for(i=0; i < n ; i++, p++, bufp += 2)
1824                     sprintf(bufp, "%02X", *p );
1825                 /* TODO: Replace the reserved '0' in the field below
1826                    with bits for status flags (policy url, notation,
1827                    etc.).  Remember to make the buffer larger to
1828                    match! */
1829                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1830                         strtimestamp( sig->timestamp ),
1831                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1832                         sig->version,sig->pubkey_algo,sig->digest_algo,
1833                         sig->sig_class);
1834                 bufp = bufp + strlen (bufp);
1835                 if (!vpk->is_primary) {
1836                    u32 akid[2];
1837  
1838                    akid[0] = vpk->main_keyid[0];
1839                    akid[1] = vpk->main_keyid[1];
1840                    free_public_key (vpk);
1841                    vpk = xmalloc_clear( sizeof *vpk );
1842                    if (get_pubkey (vpk, akid)) {
1843                      /* impossible error, we simply return a zeroed out fpr */
1844                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1845                      memset (array, 0, n);
1846                    }
1847                    else
1848                      fingerprint_from_pk( vpk, array, &n );
1849                 }
1850                 p = array;
1851                 for(i=0; i < n ; i++, p++, bufp += 2)
1852                     sprintf(bufp, "%02X", *p );
1853                 write_status_text( STATUS_VALIDSIG, buf );
1854             }
1855             free_public_key( vpk );
1856         }
1857
1858         if (!rc)
1859           {
1860             pka_uri_from_sig (sig); /* Make sure PKA info is available. */
1861             rc = check_signatures_trust( sig );
1862           }
1863
1864         if(sig->flags.expired)
1865           {
1866             log_info(_("Signature expired %s\n"),
1867                      asctimestamp(sig->expiredate));
1868             rc=G10ERR_GENERAL; /* need a better error here? */
1869           }
1870         else if(sig->expiredate)
1871           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1872
1873         if(opt.verbose)
1874           log_info(_("%s signature, digest algorithm %s\n"),
1875                    sig->sig_class==0x00?_("binary"):
1876                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1877                    digest_algo_to_string(sig->digest_algo));
1878
1879         if( rc )
1880             g10_errors_seen = 1;
1881         if( opt.batch && rc )
1882             g10_exit(1);
1883     }
1884     else {
1885         char buf[50];
1886         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1887                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1888                      sig->pubkey_algo, sig->digest_algo,
1889                      sig->sig_class, (ulong)sig->timestamp, rc );
1890         write_status_text( STATUS_ERRSIG, buf );
1891         if( rc == G10ERR_NO_PUBKEY ) {
1892             buf[16] = 0;
1893             write_status_text( STATUS_NO_PUBKEY, buf );
1894         }
1895         if( rc != G10ERR_NOT_PROCESSED )
1896             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1897     }
1898     return rc;
1899 }
1900
1901
1902 /****************
1903  * Process the tree which starts at node
1904  */
1905 static void
1906 proc_tree( CTX c, KBNODE node )
1907 {
1908     KBNODE n1;
1909     int rc;
1910
1911     if( opt.list_packets || opt.list_only )
1912         return;
1913
1914     /* we must skip our special plaintext marker packets here becuase
1915        they may be the root packet.  These packets are only used in
1916        addionla checks and skipping them here doesn't matter */
1917     while ( node
1918             && node->pkt->pkttype == PKT_GPG_CONTROL
1919             && node->pkt->pkt.gpg_control->control
1920                          == CTRLPKT_PLAINTEXT_MARK ) {
1921         node = node->next;
1922     }
1923     if (!node)
1924         return;
1925
1926     c->trustletter = ' ';
1927     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1928         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1929         merge_keys_and_selfsig( node );
1930         list_node( c, node );
1931     }
1932     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1933         merge_keys_and_selfsig( node );
1934         list_node( c, node );
1935     }
1936     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1937         /* check all signatures */
1938         if( !c->have_data ) {
1939             free_md_filter_context( &c->mfx );
1940             /* prepare to create all requested message digests */
1941             c->mfx.md = md_open(0, 0);
1942
1943             /* fixme: why looking for the signature packet and not the
1944                one-pass packet? */
1945             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1946                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1947             }
1948             /* ask for file and hash it */
1949             if( c->sigs_only ) {
1950                 rc = hash_datafiles( c->mfx.md, NULL,
1951                                      c->signed_data, c->sigfilename,
1952                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1953             }
1954             else {
1955                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1956                                                 iobuf_get_real_fname(c->iobuf),
1957                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1958             }
1959             if( rc ) {
1960                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1961                 return;
1962             }
1963         }
1964         else if ( c->signed_data ) {
1965             log_error (_("not a detached signature\n") );
1966             return;
1967         }
1968
1969         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1970             check_sig_and_print( c, n1 );
1971     }
1972     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1973              && node->pkt->pkt.gpg_control->control
1974                 == CTRLPKT_CLEARSIGN_START ) {
1975         /* clear text signed message */
1976         if( !c->have_data ) {
1977             log_error("cleartext signature without data\n" );
1978             return;
1979         }
1980         else if ( c->signed_data ) {
1981             log_error (_("not a detached signature\n") );
1982             return;
1983         }
1984         
1985         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1986             check_sig_and_print( c, n1 );
1987     }
1988     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1989         PKT_signature *sig = node->pkt->pkt.signature;
1990         int multiple_ok=1;
1991
1992         n1=find_next_kbnode(node, PKT_SIGNATURE);
1993         if(n1)
1994           {
1995             byte class=sig->sig_class;
1996             byte hash=sig->digest_algo;
1997
1998             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1999               {
2000                 /* We can't currently handle multiple signatures of
2001                    different classes or digests (we'd pretty much have
2002                    to run a different hash context for each), but if
2003                    they are all the same, make an exception. */
2004                 if(n1->pkt->pkt.signature->sig_class!=class
2005                    || n1->pkt->pkt.signature->digest_algo!=hash)
2006                   {
2007                     multiple_ok=0;
2008                     log_info(_("WARNING: multiple signatures detected.  "
2009                                "Only the first will be checked.\n"));
2010                     break;
2011                   }
2012               }
2013           }
2014
2015         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
2016             log_info(_("standalone signature of class 0x%02x\n"),
2017                                                     sig->sig_class);
2018         else if( !c->have_data ) {
2019             /* detached signature */
2020             free_md_filter_context( &c->mfx );
2021             c->mfx.md = md_open(sig->digest_algo, 0);
2022             if( !opt.pgp2_workarounds )
2023                 ;
2024             else if( sig->digest_algo == DIGEST_ALGO_MD5
2025                      && is_RSA( sig->pubkey_algo ) ) {
2026                 /* enable a workaround for a pgp2 bug */
2027                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
2028             }
2029             else if( sig->digest_algo == DIGEST_ALGO_SHA1
2030                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
2031                      && sig->sig_class == 0x01 ) {
2032                 /* enable the workaround also for pgp5 when the detached
2033                  * signature has been created in textmode */
2034                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
2035             }
2036 #if 0 /* workaround disabled */
2037             /* Here we have another hack to work around a pgp 2 bug
2038              * It works by not using the textmode for detached signatures;
2039              * this will let the first signature check (on md) fail
2040              * but the second one (on md2) which adds an extra CR should
2041              * then produce the "correct" hash.  This is very, very ugly
2042              * hack but it may help in some cases (and break others)
2043              */
2044                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
2045 #endif
2046             if ( DBG_HASHING ) {
2047                 md_start_debug( c->mfx.md, "verify" );
2048                 if ( c->mfx.md2  )
2049                     md_start_debug( c->mfx.md2, "verify2" );
2050             }
2051             if( c->sigs_only ) {
2052                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
2053                                      c->signed_data, c->sigfilename,
2054                                      (sig->sig_class == 0x01) );
2055             }
2056             else {
2057                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
2058                                                 iobuf_get_real_fname(c->iobuf),
2059                                                 (sig->sig_class == 0x01) );
2060             }
2061             if( rc ) {
2062                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2063                 return;
2064             }
2065         }
2066         else if ( c->signed_data ) {
2067             log_error (_("not a detached signature\n") );
2068             return;
2069         }
2070         else if ( c->pipemode.op == 'B' )
2071             ; /* this is a detached signature trough the pipemode handler */
2072         else if (!opt.quiet)
2073             log_info(_("old style (PGP 2.x) signature\n"));
2074
2075         if(multiple_ok)
2076           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
2077             check_sig_and_print( c, n1 );
2078         else
2079           check_sig_and_print( c, node );
2080     }
2081     else {
2082         dump_kbnode (c->list);
2083         log_error(_("invalid root packet detected in proc_tree()\n"));
2084         dump_kbnode (node);
2085     }
2086 }