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