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