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