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