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