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