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