Fixed a wrong return code with gpg --verify
[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
1534     /* If the preferred keyserver thing above didn't work, our second
1535        try is to use the URI from a DNS PKA record. */
1536     if ( rc == G10ERR_NO_PUBKEY 
1537          && (opt.keyserver_options.options&KEYSERVER_AUTO_PKA_RETRIEVE))
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
1562     /* If the preferred keyserver thing above didn't work and we got
1563        no information from the DNS PKA, this is a third try. */
1564
1565     if( rc == G10ERR_NO_PUBKEY && opt.keyserver
1566         && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE))
1567       {
1568         int res;
1569
1570         glo_ctrl.in_auto_key_retrieve++;
1571         res=keyserver_import_keyid ( sig->keyid, opt.keyserver );
1572         glo_ctrl.in_auto_key_retrieve--;
1573         if(!res)
1574           rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1575       }
1576
1577     if( !rc || rc == G10ERR_BAD_SIGN ) {
1578         KBNODE un, keyblock;
1579         int count=0, statno;
1580         char keyid_str[50];
1581         PKT_public_key *pk=NULL;
1582
1583         if(rc)
1584           statno=STATUS_BADSIG;
1585         else if(sig->flags.expired)
1586           statno=STATUS_EXPSIG;
1587         else if(is_expkey)
1588           statno=STATUS_EXPKEYSIG;
1589         else if(is_revkey)
1590           statno=STATUS_REVKEYSIG;
1591         else
1592           statno=STATUS_GOODSIG;
1593
1594         keyblock = get_pubkeyblock( sig->keyid );
1595
1596         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1597                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1598
1599         /* find and print the primary user ID */
1600         for( un=keyblock; un; un = un->next ) {
1601             char *p;
1602             int valid;
1603             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1604               {
1605                 pk=un->pkt->pkt.public_key;
1606                 continue;
1607               }
1608             if( un->pkt->pkttype != PKT_USER_ID )
1609                 continue;
1610             if ( !un->pkt->pkt.user_id->created )
1611                 continue;
1612             if ( un->pkt->pkt.user_id->is_revoked )
1613                 continue;
1614             if ( un->pkt->pkt.user_id->is_expired )
1615                 continue;
1616             if ( !un->pkt->pkt.user_id->is_primary )
1617                 continue;
1618             /* We want the textual primary user ID here */
1619             if ( un->pkt->pkt.user_id->attrib_data )
1620                 continue;
1621
1622             assert(pk);
1623
1624             /* Get it before we print anything to avoid interrupting
1625                the output with the "please do a --check-trustdb"
1626                line. */
1627             valid=get_validity(pk,un->pkt->pkt.user_id);
1628
1629             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1630             write_status_text_and_buffer (statno, keyid_str,
1631                                           un->pkt->pkt.user_id->name,
1632                                           un->pkt->pkt.user_id->len, 
1633                                           -1 );
1634
1635             p=utf8_to_native(un->pkt->pkt.user_id->name,
1636                              un->pkt->pkt.user_id->len,0);
1637
1638             if(rc)
1639               log_info(_("BAD signature from \"%s\""),p);
1640             else if(sig->flags.expired)
1641               log_info(_("Expired signature from \"%s\""),p);
1642             else
1643               log_info(_("Good signature from \"%s\""),p);
1644
1645             xfree(p);
1646
1647             if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1648               fprintf(log_stream()," [%s]\n",trust_value_to_string(valid));
1649             else
1650               fputs("\n", log_stream() );
1651             count++;
1652         }
1653         if( !count ) {  /* just in case that we have no valid textual
1654                            userid */
1655             char *p;
1656
1657             /* Try for an invalid textual userid */
1658             for( un=keyblock; un; un = un->next ) {
1659                 if( un->pkt->pkttype == PKT_USER_ID &&
1660                     !un->pkt->pkt.user_id->attrib_data )
1661                     break;
1662             }
1663
1664             /* Try for any userid at all */
1665             if(!un) {
1666                 for( un=keyblock; un; un = un->next ) {
1667                     if( un->pkt->pkttype == PKT_USER_ID )
1668                         break;
1669                 }
1670             }
1671
1672             if (opt.trust_model==TM_ALWAYS || !un)
1673                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1674
1675             write_status_text_and_buffer (statno, keyid_str,
1676                                           un? un->pkt->pkt.user_id->name:"[?]",
1677                                           un? un->pkt->pkt.user_id->len:3, 
1678                                           -1 );
1679
1680             if(un)
1681               p=utf8_to_native(un->pkt->pkt.user_id->name,
1682                                un->pkt->pkt.user_id->len,0);
1683             else
1684               p=xstrdup("[?]");
1685
1686             if(rc)
1687               log_info(_("BAD signature from \"%s\""),p);
1688             else if(sig->flags.expired)
1689               log_info(_("Expired signature from \"%s\""),p);
1690             else
1691               log_info(_("Good signature from \"%s\""),p);
1692             if (opt.trust_model!=TM_ALWAYS && un)
1693               {
1694                 putc(' ', log_stream() );
1695                 fputs(_("[uncertain]"), log_stream() );
1696               }
1697             fputs("\n", log_stream() );
1698         }
1699
1700         /* If we have a good signature and already printed 
1701          * the primary user ID, print all the other user IDs */
1702         if ( count && !rc ) {
1703             char *p;
1704             for( un=keyblock; un; un = un->next ) {
1705                 if( un->pkt->pkttype != PKT_USER_ID )
1706                     continue;
1707                 if((un->pkt->pkt.user_id->is_revoked
1708                     || un->pkt->pkt.user_id->is_expired)
1709                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1710                   continue;
1711                 /* Only skip textual primaries */
1712                 if ( un->pkt->pkt.user_id->is_primary &&
1713                      !un->pkt->pkt.user_id->attrib_data )
1714                     continue;
1715
1716                 if(un->pkt->pkt.user_id->attrib_data)
1717                   {
1718                     dump_attribs(un->pkt->pkt.user_id,pk,NULL);
1719
1720                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1721                       show_photos(un->pkt->pkt.user_id->attribs,
1722                                   un->pkt->pkt.user_id->numattribs,pk,NULL);
1723                   }
1724
1725                 p=utf8_to_native(un->pkt->pkt.user_id->name,
1726                                  un->pkt->pkt.user_id->len,0);
1727                 log_info(_("                aka \"%s\""),p);
1728                 xfree(p);
1729
1730                 if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1731                   {
1732                     const char *valid;
1733                     if(un->pkt->pkt.user_id->is_revoked)
1734                       valid=_("revoked");
1735                     else if(un->pkt->pkt.user_id->is_expired)
1736                       valid=_("expired");
1737                     else
1738                       valid=trust_value_to_string(get_validity(pk,
1739                                                                un->pkt->
1740                                                                pkt.user_id));
1741                     fprintf(log_stream()," [%s]\n",valid);
1742                   }
1743                 else
1744                   fputs("\n", log_stream() );
1745             }
1746         }
1747         release_kbnode( keyblock );
1748
1749         if( !rc )
1750           {
1751             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1752               show_policy_url(sig,0,1);
1753             else
1754               show_policy_url(sig,0,2);
1755
1756             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1757               show_keyserver_url(sig,0,1);
1758             else
1759               show_keyserver_url(sig,0,2);
1760
1761             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1762               show_notation(sig,0,1,
1763                         ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
1764                         ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
1765             else
1766               show_notation(sig,0,2,0);
1767           }
1768
1769         if( !rc && is_status_enabled() ) {
1770             /* print a status response with the fingerprint */
1771             PKT_public_key *vpk = xmalloc_clear( sizeof *vpk );
1772
1773             if( !get_pubkey( vpk, sig->keyid ) ) {
1774                 byte array[MAX_FINGERPRINT_LEN], *p;
1775                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1776                 size_t i, n;
1777
1778                 bufp = buf;
1779                 fingerprint_from_pk( vpk, array, &n );
1780                 p = array;
1781                 for(i=0; i < n ; i++, p++, bufp += 2)
1782                     sprintf(bufp, "%02X", *p );
1783                 /* TODO: Replace the reserved '0' in the field below
1784                    with bits for status flags (policy url, notation,
1785                    etc.).  Remember to make the buffer larger to
1786                    match! */
1787                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1788                         strtimestamp( sig->timestamp ),
1789                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1790                         sig->version,sig->pubkey_algo,sig->digest_algo,
1791                         sig->sig_class);
1792                 bufp = bufp + strlen (bufp);
1793                 if (!vpk->is_primary) {
1794                    u32 akid[2];
1795  
1796                    akid[0] = vpk->main_keyid[0];
1797                    akid[1] = vpk->main_keyid[1];
1798                    free_public_key (vpk);
1799                    vpk = xmalloc_clear( sizeof *vpk );
1800                    if (get_pubkey (vpk, akid)) {
1801                      /* impossible error, we simply return a zeroed out fpr */
1802                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1803                      memset (array, 0, n);
1804                    }
1805                    else
1806                      fingerprint_from_pk( vpk, array, &n );
1807                 }
1808                 p = array;
1809                 for(i=0; i < n ; i++, p++, bufp += 2)
1810                     sprintf(bufp, "%02X", *p );
1811                 write_status_text( STATUS_VALIDSIG, buf );
1812             }
1813             free_public_key( vpk );
1814         }
1815
1816         if (!rc)
1817           {
1818             pka_uri_from_sig (sig); /* Make sure PKA info is available. */
1819             rc = check_signatures_trust( sig );
1820           }
1821
1822         if(sig->flags.expired)
1823           {
1824             log_info(_("Signature expired %s\n"),
1825                      asctimestamp(sig->expiredate));
1826             rc=G10ERR_GENERAL; /* need a better error here? */
1827           }
1828         else if(sig->expiredate)
1829           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1830
1831         if(opt.verbose)
1832           log_info(_("%s signature, digest algorithm %s\n"),
1833                    sig->sig_class==0x00?_("binary"):
1834                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1835                    digest_algo_to_string(sig->digest_algo));
1836
1837         if( rc )
1838             g10_errors_seen = 1;
1839         if( opt.batch && rc )
1840             g10_exit(1);
1841     }
1842     else {
1843         char buf[50];
1844         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1845                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1846                      sig->pubkey_algo, sig->digest_algo,
1847                      sig->sig_class, (ulong)sig->timestamp, rc );
1848         write_status_text( STATUS_ERRSIG, buf );
1849         if( rc == G10ERR_NO_PUBKEY ) {
1850             buf[16] = 0;
1851             write_status_text( STATUS_NO_PUBKEY, buf );
1852         }
1853         if( rc != G10ERR_NOT_PROCESSED )
1854             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1855     }
1856     return rc;
1857 }
1858
1859
1860 /****************
1861  * Process the tree which starts at node
1862  */
1863 static void
1864 proc_tree( CTX c, KBNODE node )
1865 {
1866     KBNODE n1;
1867     int rc;
1868
1869     if( opt.list_packets || opt.list_only )
1870         return;
1871
1872     /* we must skip our special plaintext marker packets here becuase
1873        they may be the root packet.  These packets are only used in
1874        addionla checks and skipping them here doesn't matter */
1875     while ( node
1876             && node->pkt->pkttype == PKT_GPG_CONTROL
1877             && node->pkt->pkt.gpg_control->control
1878                          == CTRLPKT_PLAINTEXT_MARK ) {
1879         node = node->next;
1880     }
1881     if (!node)
1882         return;
1883
1884     c->trustletter = ' ';
1885     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1886         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1887         merge_keys_and_selfsig( node );
1888         list_node( c, node );
1889     }
1890     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1891         merge_keys_and_selfsig( node );
1892         list_node( c, node );
1893     }
1894     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1895         /* check all signatures */
1896         if( !c->have_data ) {
1897             free_md_filter_context( &c->mfx );
1898             /* prepare to create all requested message digests */
1899             c->mfx.md = md_open(0, 0);
1900
1901             /* fixme: why looking for the signature packet and not 1passpacket*/
1902             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1903                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1904             }
1905             /* ask for file and hash it */
1906             if( c->sigs_only ) {
1907                 rc = hash_datafiles( c->mfx.md, NULL,
1908                                      c->signed_data, c->sigfilename,
1909                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1910             }
1911             else {
1912                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1913                                                 iobuf_get_real_fname(c->iobuf),
1914                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1915             }
1916             if( rc ) {
1917                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1918                 return;
1919             }
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_GPG_CONTROL
1930              && node->pkt->pkt.gpg_control->control
1931                 == CTRLPKT_CLEARSIGN_START ) {
1932         /* clear text signed message */
1933         if( !c->have_data ) {
1934             log_error("cleartext signature without data\n" );
1935             return;
1936         }
1937         else if ( c->signed_data ) {
1938             log_error (_("not a detached signature\n") );
1939             return;
1940         }
1941         
1942         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1943             check_sig_and_print( c, n1 );
1944     }
1945     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1946         PKT_signature *sig = node->pkt->pkt.signature;
1947         int multiple_ok=1;
1948
1949         n1=find_next_kbnode(node, PKT_SIGNATURE);
1950         if(n1)
1951           {
1952             byte class=sig->sig_class;
1953             byte hash=sig->digest_algo;
1954
1955             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1956               {
1957                 /* We can't currently handle multiple signatures of
1958                    different classes or digests (we'd pretty much have
1959                    to run a different hash context for each), but if
1960                    they are all the same, make an exception. */
1961                 if(n1->pkt->pkt.signature->sig_class!=class
1962                    || n1->pkt->pkt.signature->digest_algo!=hash)
1963                   {
1964                     multiple_ok=0;
1965                     log_info(_("WARNING: multiple signatures detected.  "
1966                                "Only the first will be checked.\n"));
1967                     break;
1968                   }
1969               }
1970           }
1971
1972         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
1973             log_info(_("standalone signature of class 0x%02x\n"),
1974                                                     sig->sig_class);
1975         else if( !c->have_data ) {
1976             /* detached signature */
1977             free_md_filter_context( &c->mfx );
1978             c->mfx.md = md_open(sig->digest_algo, 0);
1979             if( !opt.pgp2_workarounds )
1980                 ;
1981             else if( sig->digest_algo == DIGEST_ALGO_MD5
1982                      && is_RSA( sig->pubkey_algo ) ) {
1983                 /* enable a workaround for a pgp2 bug */
1984                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1985             }
1986             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1987                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1988                      && sig->sig_class == 0x01 ) {
1989                 /* enable the workaround also for pgp5 when the detached
1990                  * signature has been created in textmode */
1991                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1992             }
1993 #if 0 /* workaround disabled */
1994             /* Here we have another hack to work around a pgp 2 bug
1995              * It works by not using the textmode for detached signatures;
1996              * this will let the first signature check (on md) fail
1997              * but the second one (on md2) which adds an extra CR should
1998              * then produce the "correct" hash.  This is very, very ugly
1999              * hack but it may help in some cases (and break others)
2000              */
2001                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
2002 #endif
2003             if ( DBG_HASHING ) {
2004                 md_start_debug( c->mfx.md, "verify" );
2005                 if ( c->mfx.md2  )
2006                     md_start_debug( c->mfx.md2, "verify2" );
2007             }
2008             if( c->sigs_only ) {
2009                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
2010                                      c->signed_data, c->sigfilename,
2011                                      (sig->sig_class == 0x01) );
2012             }
2013             else {
2014                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
2015                                                 iobuf_get_real_fname(c->iobuf),
2016                                                 (sig->sig_class == 0x01) );
2017             }
2018             if( rc ) {
2019                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2020                 return;
2021             }
2022         }
2023         else if ( c->signed_data ) {
2024             log_error (_("not a detached signature\n") );
2025             return;
2026         }
2027         else if ( c->pipemode.op == 'B' )
2028             ; /* this is a detached signature trough the pipemode handler */
2029         else if (!opt.quiet)
2030             log_info(_("old style (PGP 2.x) signature\n"));
2031
2032         if(multiple_ok)
2033           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
2034             check_sig_and_print( c, n1 );
2035         else
2036           check_sig_and_print( c, node );
2037     }
2038     else {
2039         dump_kbnode (c->list);
2040         log_error(_("invalid root packet detected in proc_tree()\n"));
2041         dump_kbnode (node);
2042     }
2043 }