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