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