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