* keygen.c (do_add_key_flags): Don't set the certify flag for subkeys.
[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, int *is_expkey )
664 {
665     PKT_signature *sig;
666     MD_HANDLE md = NULL, md2 = NULL;
667     int algo, rc, dum2;
668
669     if(!is_expkey)
670       is_expkey=&dum2;
671
672     assert( node->pkt->pkttype == PKT_SIGNATURE );
673     if( is_selfsig )
674         *is_selfsig = 0;
675     sig = node->pkt->pkt.signature;
676
677     algo = sig->digest_algo;
678     if( (rc=check_digest_algo(algo)) )
679         return rc;
680
681     if( sig->sig_class == 0x00 ) {
682         if( c->mfx.md )
683             md = md_copy( c->mfx.md );
684         else /* detached signature */
685             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
686     }
687     else if( sig->sig_class == 0x01 ) {
688         /* how do we know that we have to hash the (already hashed) text
689          * in canonical mode ??? (calculating both modes???) */
690         if( c->mfx.md ) {
691             md = md_copy( c->mfx.md );
692             if( c->mfx.md2 )
693                md2 = md_copy( c->mfx.md2 );
694         }
695         else { /* detached signature */
696           log_debug("Do we really need this here?");
697             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
698             md2 = md_open( 0, 0 );
699         }
700     }
701     else if( (sig->sig_class&~3) == 0x10
702              || sig->sig_class == 0x18
703              || sig->sig_class == 0x1f
704              || sig->sig_class == 0x20
705              || sig->sig_class == 0x28
706              || sig->sig_class == 0x30  ) { 
707         if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
708             || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
709             return check_key_signature( c->list, node, is_selfsig );
710         }
711         else if( sig->sig_class == 0x20 ) {
712             log_info(_("standalone revocation - "
713                        "use \"gpg --import\" to apply\n"));
714             return G10ERR_NOT_PROCESSED;
715         }
716         else {
717             log_error("invalid root packet for sigclass %02x\n",
718                                                         sig->sig_class);
719             return G10ERR_SIG_CLASS;
720         }
721     }
722     else
723         return G10ERR_SIG_CLASS;
724     rc = signature_check2( sig, md, NULL, is_expkey, NULL );
725     if( rc == G10ERR_BAD_SIGN && md2 )
726         rc = signature_check2( sig, md2, NULL, is_expkey, NULL );
727     md_close(md);
728     md_close(md2);
729
730     return rc;
731 }
732
733
734 static void
735 print_userid( PACKET *pkt )
736 {
737     if( !pkt )
738         BUG();
739     if( pkt->pkttype != PKT_USER_ID ) {
740         printf("ERROR: unexpected packet type %d", pkt->pkttype );
741         return;
742     }
743     if( opt.with_colons )
744       {
745         if(pkt->pkt.user_id->attrib_data)
746           printf("%u %lu",
747                  pkt->pkt.user_id->numattribs,
748                  pkt->pkt.user_id->attrib_len);
749         else
750           print_string( stdout,  pkt->pkt.user_id->name,
751                         pkt->pkt.user_id->len, ':');
752       }
753     else
754         print_utf8_string( stdout,  pkt->pkt.user_id->name,
755                                      pkt->pkt.user_id->len );
756 }
757
758
759 /****************
760  * List the certificate in a user friendly way
761  */
762
763 static void
764 list_node( CTX c, KBNODE node )
765 {
766     int any=0;
767     int mainkey;
768
769     if( !node )
770         ;
771     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
772              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
773         PKT_public_key *pk = node->pkt->pkt.public_key;
774
775         if( opt.with_colons ) {
776             u32 keyid[2];
777             keyid_from_pk( pk, keyid );
778             if( mainkey ) {
779                 c->local_id = pk->local_id;
780                 c->trustletter = opt.fast_list_mode?
781                                            0 : get_validity_info( pk, NULL );
782             }
783             printf("%s:", mainkey? "pub":"sub" );
784             if( c->trustletter )
785                 putchar( c->trustletter );
786             printf(":%u:%d:%08lX%08lX:%s:%s:",
787                     nbits_from_pk( pk ),
788                     pk->pubkey_algo,
789                     (ulong)keyid[0],(ulong)keyid[1],
790                     colon_datestr_from_pk( pk ),
791                     colon_strtime (pk->expiredate) );
792             if( c->local_id )
793                 printf("%lu", c->local_id );
794             putchar(':');
795             if( mainkey && !opt.fast_list_mode )
796                  putchar( get_ownertrust_info (pk) );
797             putchar(':');
798             if( node->next && node->next->pkt->pkttype == PKT_RING_TRUST) {
799                 putchar('\n'); any=1;
800                 if( opt.fingerprint )
801                     print_fingerprint( pk, NULL, 0 );
802                 printf("rtv:1:%u:\n",
803                             node->next->pkt->pkt.ring_trust->trustval );
804             }
805         }
806         else
807             printf("%s  %4u%c/%08lX %s ",
808                                       mainkey? "pub":"sub",
809                                       nbits_from_pk( pk ),
810                                       pubkey_letter( pk->pubkey_algo ),
811                                       (ulong)keyid_from_pk( pk, NULL ),
812                                       datestr_from_pk( pk )     );
813
814         if( mainkey ) {
815             /* and now list all userids with their signatures */
816             for( node = node->next; node; node = node->next ) {
817                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
818                     if( !any ) {
819                         if( node->pkt->pkt.signature->sig_class == 0x20 )
820                             puts("[revoked]");
821                         else
822                             putchar('\n');
823                         any = 1;
824                     }
825                     list_node(c,  node );
826                 }
827                 else if( node->pkt->pkttype == PKT_USER_ID ) {
828                     if( any ) {
829                         if( opt.with_colons )
830                             printf("%s:::::::::",
831                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
832                         else
833                             printf( "uid%*s", 28, "" );
834                     }
835                     print_userid( node->pkt );
836                     if( opt.with_colons )
837                         putchar(':');
838                     putchar('\n');
839                     if( opt.fingerprint && !any )
840                         print_fingerprint( pk, NULL, 0 );
841                     if( node->next
842                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
843                         printf("rtv:2:%u:\n",
844                                  node->next->pkt->pkt.ring_trust->trustval );
845                     }
846                     any=1;
847                 }
848                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
849                     if( !any ) {
850                         putchar('\n');
851                         any = 1;
852                     }
853                     list_node(c,  node );
854                 }
855             }
856         }
857         else if( pk->expiredate ) { /* of subkey */
858             printf(_(" [expires: %s]"), expirestr_from_pk( pk ) );
859         }
860
861         if( !any )
862             putchar('\n');
863         if( !mainkey && opt.fingerprint > 1 )
864             print_fingerprint( pk, NULL, 0 );
865     }
866     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
867              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
868         PKT_secret_key *sk = node->pkt->pkt.secret_key;
869
870         if( opt.with_colons ) {
871             u32 keyid[2];
872             keyid_from_sk( sk, keyid );
873             printf("%s::%u:%d:%08lX%08lX:%s:%s:::",
874                     mainkey? "sec":"ssb",
875                     nbits_from_sk( sk ),
876                     sk->pubkey_algo,
877                     (ulong)keyid[0],(ulong)keyid[1],
878                     colon_datestr_from_sk( sk ),
879                     colon_strtime (sk->expiredate)
880                     /* fixme: add LID */ );
881         }
882         else
883             printf("%s  %4u%c/%08lX %s ",
884                                       mainkey? "sec":"ssb",
885                                       nbits_from_sk( sk ),
886                                       pubkey_letter( sk->pubkey_algo ),
887                                       (ulong)keyid_from_sk( sk, NULL ),
888                                       datestr_from_sk( sk )   );
889         if( mainkey ) {
890             /* and now list all userids with their signatures */
891             for( node = node->next; node; node = node->next ) {
892                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
893                     if( !any ) {
894                         if( node->pkt->pkt.signature->sig_class == 0x20 )
895                             puts("[revoked]");
896                         else
897                             putchar('\n');
898                         any = 1;
899                     }
900                     list_node(c,  node );
901                 }
902                 else if( node->pkt->pkttype == PKT_USER_ID ) {
903                     if( any ) {
904                         if( opt.with_colons )
905                             printf("%s:::::::::",
906                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
907                         else
908                             printf( "uid%*s", 28, "" );
909                     }
910                     print_userid( node->pkt );
911                     if( opt.with_colons )
912                         putchar(':');
913                     putchar('\n');
914                     if( opt.fingerprint && !any )
915                         print_fingerprint( NULL, sk, 0 );
916                     any=1;
917                 }
918                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
919                     if( !any ) {
920                         putchar('\n');
921                         any = 1;
922                     }
923                     list_node(c,  node );
924                 }
925             }
926         }
927         if( !any )
928             putchar('\n');
929         if( !mainkey && opt.fingerprint > 1 )
930             print_fingerprint( NULL, sk, 0 );
931     }
932     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
933         PKT_signature *sig = node->pkt->pkt.signature;
934         int is_selfsig = 0;
935         int rc2=0;
936         size_t n;
937         char *p;
938         int sigrc = ' ';
939
940         if( !opt.list_sigs )
941             return;
942
943         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
944             fputs("rev", stdout);
945         else
946             fputs("sig", stdout);
947         if( opt.check_sigs ) {
948             fflush(stdout);
949             switch( (rc2=do_check_sig( c, node, &is_selfsig, NULL )) ) {
950               case 0:                  sigrc = '!'; break;
951               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
952               case G10ERR_NO_PUBKEY: 
953               case G10ERR_UNU_PUBKEY:  sigrc = '?'; break;
954               default:                 sigrc = '%'; break;
955             }
956         }
957         else {  /* check whether this is a self signature */
958             u32 keyid[2];
959
960             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
961                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
962                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
963                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
964                 else
965                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
966
967                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
968                     is_selfsig = 1;
969             }
970         }
971         if( opt.with_colons ) {
972             putchar(':');
973             if( sigrc != ' ' )
974                 putchar(sigrc);
975             printf("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
976                    (ulong)sig->keyid[0], (ulong)sig->keyid[1],
977                    colon_datestr_from_sig(sig),
978                    colon_expirestr_from_sig(sig));
979
980             if(sig->trust_depth || sig->trust_value)
981               printf("%d %d",sig->trust_depth,sig->trust_value);
982             printf(":");
983
984             if(sig->trust_regexp)
985               print_string(stdout,sig->trust_regexp,
986                            strlen(sig->trust_regexp),':');
987             printf(":");
988         }
989         else
990             printf("%c       %08lX %s   ",
991                     sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
992         if( sigrc == '%' )
993             printf("[%s] ", g10_errstr(rc2) );
994         else if( sigrc == '?' )
995             ;
996         else if( is_selfsig ) {
997             if( opt.with_colons )
998                 putchar(':');
999             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
1000             if( opt.with_colons )
1001                 putchar(':');
1002         }
1003         else if( !opt.fast_list_mode ) {
1004             p = get_user_id( sig->keyid, &n );
1005             print_string( stdout, p, n, opt.with_colons );
1006             m_free(p);
1007         }
1008         if( opt.with_colons )
1009             printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1010         putchar('\n');
1011     }
1012     else
1013         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
1014 }
1015
1016
1017
1018 int
1019 proc_packets( void *anchor, IOBUF a )
1020 {
1021     int rc;
1022     CTX c = m_alloc_clear( sizeof *c );
1023
1024     c->anchor = anchor;
1025     rc = do_proc_packets( c, a );
1026     m_free( c );
1027     return rc;
1028 }
1029
1030
1031
1032 int
1033 proc_signature_packets( void *anchor, IOBUF a,
1034                         STRLIST signedfiles, const char *sigfilename )
1035 {
1036     CTX c = m_alloc_clear( sizeof *c );
1037     int rc;
1038
1039     c->anchor = anchor;
1040     c->sigs_only = 1;
1041     c->signed_data = signedfiles;
1042     c->sigfilename = sigfilename;
1043     rc = do_proc_packets( c, a );
1044     m_free( c );
1045     return rc;
1046 }
1047
1048 int
1049 proc_encryption_packets( void *anchor, IOBUF a )
1050 {
1051     CTX c = m_alloc_clear( sizeof *c );
1052     int rc;
1053
1054     c->anchor = anchor;
1055     c->encrypt_only = 1;
1056     rc = do_proc_packets( c, a );
1057     m_free( c );
1058     return rc;
1059 }
1060
1061
1062 int
1063 do_proc_packets( CTX c, IOBUF a )
1064 {
1065     PACKET *pkt = m_alloc( sizeof *pkt );
1066     int rc=0;
1067     int any_data=0;
1068     int newpkt;
1069
1070     c->iobuf = a;
1071     init_packet(pkt);
1072     while( (rc=parse_packet(a, pkt)) != -1 ) {
1073         any_data = 1;
1074         if( rc ) {
1075             free_packet(pkt);
1076             /* stop processing when an invalid packet has been encountered
1077              * but don't do so when we are doing a --list-packet. */
1078             if( rc == G10ERR_INVALID_PACKET && opt.list_packets != 2 )
1079                 break;
1080             continue;
1081         }
1082         newpkt = -1;
1083         if( opt.list_packets ) {
1084             switch( pkt->pkttype ) {
1085               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1086               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1087               case PKT_ENCRYPTED:
1088               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1089               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1090               default: newpkt = 0; break;
1091             }
1092         }
1093         else if( c->sigs_only ) {
1094             switch( pkt->pkttype ) {
1095               case PKT_PUBLIC_KEY:
1096               case PKT_SECRET_KEY:
1097               case PKT_USER_ID:
1098               case PKT_SYMKEY_ENC:
1099               case PKT_PUBKEY_ENC:
1100               case PKT_ENCRYPTED:
1101               case PKT_ENCRYPTED_MDC:
1102                 write_status_text( STATUS_UNEXPECTED, "0" );
1103                 rc = G10ERR_UNEXPECTED;
1104                 goto leave;
1105               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1106               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1107               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1108               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1109               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1110               default: newpkt = 0; break;
1111             }
1112         }
1113         else if( c->encrypt_only ) {
1114             switch( pkt->pkttype ) {
1115               case PKT_PUBLIC_KEY:
1116               case PKT_SECRET_KEY:
1117               case PKT_USER_ID:
1118                 write_status_text( STATUS_UNEXPECTED, "0" );
1119                 rc = G10ERR_UNEXPECTED;
1120                 goto leave;
1121               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1122               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1123               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1124               case PKT_ENCRYPTED:
1125               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1126               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1127               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1128               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1129               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1130               default: newpkt = 0; break;
1131             }
1132         }
1133         else {
1134             switch( pkt->pkttype ) {
1135               case PKT_PUBLIC_KEY:
1136               case PKT_SECRET_KEY:
1137                 release_list( c );
1138                 c->list = new_kbnode( pkt );
1139                 newpkt = 1;
1140                 break;
1141               case PKT_PUBLIC_SUBKEY:
1142               case PKT_SECRET_SUBKEY:
1143                 newpkt = add_subkey( c, pkt );
1144                 break;
1145               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1146               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1147               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1148               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1149               case PKT_ENCRYPTED:
1150               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1151               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1152               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1153               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1154               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1155               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1156               default: newpkt = 0; break;
1157             }
1158         }
1159         /* This is a very ugly construct and frankly, I don't remember why
1160          * I used it.  Adding the MDC check here is a hack.
1161          * The right solution is to initiate another context for encrypted
1162          * packet and not to reuse the current one ...  It works right
1163          * when there is a compression packet inbetween which adds just
1164          * an extra layer.
1165          * Hmmm: Rewrite this whole module here?? 
1166          */
1167         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1168             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
1169
1170         if( newpkt == -1 )
1171             ;
1172         else if( newpkt ) {
1173             pkt = m_alloc( sizeof *pkt );
1174             init_packet(pkt);
1175         }
1176         else
1177             free_packet(pkt);
1178         if ( c->pipemode.stop_now ) {
1179             /* we won't get an EOF in pipemode, so we have to 
1180              * break the loop here */ 
1181             rc = -1;
1182             break;
1183         }
1184     }
1185     if( rc == G10ERR_INVALID_PACKET )
1186         write_status_text( STATUS_NODATA, "3" );
1187     if( any_data )
1188         rc = 0;
1189     else if( rc == -1 )
1190         write_status_text( STATUS_NODATA, "2" );
1191
1192
1193   leave:
1194     release_list( c );
1195     m_free(c->dek);
1196     free_packet( pkt );
1197     m_free( pkt );
1198     free_md_filter_context( &c->mfx );
1199     return rc;
1200 }
1201
1202
1203 static int
1204 check_sig_and_print( CTX c, KBNODE node )
1205 {
1206     PKT_signature *sig = node->pkt->pkt.signature;
1207     const char *astr, *tstr;
1208     int rc, is_expkey=0;
1209
1210     if( opt.skip_verify ) {
1211         log_info(_("signature verification suppressed\n"));
1212         return 0;
1213     }
1214
1215     /* It is not in all cases possible to check multiple signatures:
1216      * PGP 2 (which is also allowed by OpenPGP), does use the packet
1217      * sequence: sig+data,  OpenPGP does use onepas+data=sig and GnuPG
1218      * sometimes uses (because I did'nt read the specs right) data+sig.
1219      * Because it is possible to create multiple signatures with
1220      * different packet sequence (e.g. data+sig and sig+data) it might
1221      * not be possible to get it right:  let's say we have:
1222      * data+sig, sig+data,sig+data and we have not yet encountered the last
1223      * data, we could also see this a one data with 2 signatures and then 
1224      * data+sig.
1225      * To protect against this we check that all signatures follow
1226      * without any intermediate packets.  Note, that we won't get this
1227      * error when we use onepass packets or cleartext signatures because
1228      * we reset the list every time
1229      *
1230      * FIXME: Now that we have these marker packets, we should create a 
1231      * real grammar and check against this.
1232      */
1233     {
1234         KBNODE n;
1235         int n_sig=0;
1236
1237         for (n=c->list; n; n=n->next ) {
1238             if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1239                 n_sig++;
1240         }
1241         if (n_sig > 1) { /* more than one signature - check sequence */
1242             int tmp, onepass;
1243
1244             for (tmp=onepass=0,n=c->list; n; n=n->next ) {
1245                 if (n->pkt->pkttype == PKT_ONEPASS_SIG) 
1246                     onepass++;
1247                 else if (n->pkt->pkttype == PKT_GPG_CONTROL
1248                          && n->pkt->pkt.gpg_control->control
1249                             == CTRLPKT_CLEARSIGN_START ) {
1250                     onepass++; /* handle the same way as a onepass */
1251                 }
1252                 else if ( (tmp && n->pkt->pkttype != PKT_SIGNATURE) ) {
1253                     log_error(_("can't handle these multiple signatures\n"));
1254                     return 0;
1255                 }
1256                 else if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1257                     tmp = 1;
1258                 else if (!tmp && !onepass 
1259                          && n->pkt->pkttype == PKT_GPG_CONTROL
1260                          && n->pkt->pkt.gpg_control->control
1261                             == CTRLPKT_PLAINTEXT_MARK ) {
1262                     /* plaintext before signatures but no one-pass packets*/
1263                     log_error(_("can't handle these multiple signatures\n"));
1264                     return 0;
1265                 }
1266             }
1267         }
1268     }
1269
1270     tstr = asctimestamp(sig->timestamp);
1271     astr = pubkey_algo_to_string( sig->pubkey_algo );
1272     if(opt.verify_options&VERIFY_SHOW_LONG_KEYID)
1273       {
1274         log_info(_("Signature made %.*s\n"),(int)strlen(tstr), tstr);
1275         log_info(_("               using %s key %08lX%08lX\n"),
1276                  astr? astr: "?",(ulong)sig->keyid[0],(ulong)sig->keyid[1] );
1277       }
1278     else
1279       log_info(_("Signature made %.*s using %s key ID %08lX\n"),
1280                (int)strlen(tstr), tstr, astr? astr: "?",
1281                (ulong)sig->keyid[1] );
1282
1283     rc = do_check_sig(c, node, NULL, &is_expkey );
1284     if( rc == G10ERR_NO_PUBKEY && opt.keyserver_scheme && opt.keyserver_options.auto_key_retrieve) {
1285         if( keyserver_import_keyid ( sig->keyid )==0 )
1286             rc = do_check_sig(c, node, NULL, &is_expkey );
1287     }
1288
1289     /* If the key still isn't found, try to inform the user where it
1290        can be found. */
1291
1292     if(rc==G10ERR_NO_PUBKEY && opt.verify_options&VERIFY_SHOW_KEYSERVER)
1293       {
1294         const byte *p;
1295         int seq=0;
1296         size_t n;
1297
1298         while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1299           {
1300             /* According to my favorite copy editor, in English
1301                grammar, you say "at" if the key is located on a web
1302                page, but "from" if it is located on a keyserver.  I'm
1303                not going to even try to make two strings here :) */
1304             log_info(_("Key available at: ") );
1305             print_string( log_stream(), p, n, 0 );
1306             putc( '\n', log_stream() );
1307           }
1308       }
1309
1310     if( !rc || rc == G10ERR_BAD_SIGN ) {
1311         KBNODE un, keyblock;
1312         int count=0, statno;
1313         char keyid_str[50];
1314         PKT_public_key *pk=NULL;
1315
1316         if(rc)
1317           statno=STATUS_BADSIG;
1318         else if(sig->flags.expired)
1319           statno=STATUS_EXPSIG;
1320         else if(is_expkey)
1321           statno=STATUS_EXPKEYSIG;
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             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1333               {
1334                 pk=un->pkt->pkt.public_key;
1335                 continue;
1336               }
1337             if( un->pkt->pkttype != PKT_USER_ID )
1338                 continue;
1339             if ( !un->pkt->pkt.user_id->created )
1340                 continue;
1341             if ( un->pkt->pkt.user_id->is_revoked )
1342                 continue;
1343             if ( un->pkt->pkt.user_id->is_expired )
1344                 continue;
1345             if ( !un->pkt->pkt.user_id->is_primary )
1346                 continue;
1347             /* We want the textual user ID here */
1348             if ( un->pkt->pkt.user_id->attrib_data )
1349                 continue;
1350
1351             assert(pk);
1352
1353             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1354             write_status_text_and_buffer (statno, keyid_str,
1355                                           un->pkt->pkt.user_id->name,
1356                                           un->pkt->pkt.user_id->len, 
1357                                           -1 );
1358
1359             log_info(rc? _("BAD signature from \"")
1360                        : sig->flags.expired ? _("Expired signature from \"")
1361                        : _("Good signature from \""));
1362             print_utf8_string( log_stream(), un->pkt->pkt.user_id->name,
1363                                              un->pkt->pkt.user_id->len );
1364             if(opt.verify_options&VERIFY_SHOW_VALIDITY)
1365               fprintf(log_stream(),"\" [%s]\n",
1366                       trust_value_to_string(get_validity(pk,
1367                                                        un->pkt->pkt.user_id)));
1368             else
1369               fputs("\"\n", log_stream() );
1370             count++;
1371         }
1372         if( !count ) {  /* just in case that we have no valid textual
1373                            userid */
1374             /* Try for an invalid textual userid */
1375             for( un=keyblock; un; un = un->next ) {
1376                 if( un->pkt->pkttype == PKT_USER_ID &&
1377                     !un->pkt->pkt.user_id->attrib_data )
1378                     break;
1379             }
1380
1381             /* Try for any userid at all */
1382             if(!un) {
1383                 for( un=keyblock; un; un = un->next ) {
1384                     if( un->pkt->pkttype == PKT_USER_ID )
1385                         break;
1386                 }
1387             }
1388
1389             if (opt.trust_model==TM_ALWAYS || !un)
1390                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1391
1392             write_status_text_and_buffer (statno, keyid_str,
1393                                           un? un->pkt->pkt.user_id->name:"[?]",
1394                                           un? un->pkt->pkt.user_id->len:3, 
1395                                           -1 );
1396
1397             log_info(rc? _("BAD signature from \"")
1398                        : sig->flags.expired ? _("Expired signature from \"")
1399                        : _("Good signature from \""));
1400             if (opt.trust_model!=TM_ALWAYS && un) {
1401                 fputs(_("[uncertain]"), log_stream() );
1402                 putc(' ', log_stream() );
1403             }
1404             print_utf8_string( log_stream(),
1405                                un? un->pkt->pkt.user_id->name:"[?]",
1406                                un? un->pkt->pkt.user_id->len:3 );
1407             fputs("\"\n", log_stream() );
1408         }
1409
1410         /* If we have a good signature and already printed 
1411          * the primary user ID, print all the other user IDs */
1412         if ( count && !rc ) {
1413             for( un=keyblock; un; un = un->next ) {
1414                 if( un->pkt->pkttype != PKT_USER_ID )
1415                     continue;
1416                 if ( un->pkt->pkt.user_id->is_revoked )
1417                     continue;
1418                 if ( un->pkt->pkt.user_id->is_expired )
1419                     continue;
1420                 /* Only skip textual primaries */
1421                 if ( un->pkt->pkt.user_id->is_primary &&
1422                      !un->pkt->pkt.user_id->attrib_data )
1423                     continue;
1424
1425                 if(un->pkt->pkt.user_id->attrib_data)
1426                   {
1427                     dump_attribs(un->pkt->pkt.user_id,pk,NULL);
1428
1429                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1430                       show_photos(un->pkt->pkt.user_id->attribs,
1431                                   un->pkt->pkt.user_id->numattribs,pk,NULL);
1432                   }
1433
1434                 log_info(    _("                aka \""));
1435                 print_utf8_string( log_stream(), un->pkt->pkt.user_id->name,
1436                                                  un->pkt->pkt.user_id->len );
1437
1438                 if(opt.verify_options&VERIFY_SHOW_VALIDITY)
1439                   fprintf(log_stream(),"\" [%s]\n",
1440                           trust_value_to_string(get_validity(pk,
1441                                                              un->pkt->
1442                                                              pkt.user_id)));
1443                 else
1444                   fputs("\"\n", log_stream() );
1445             }
1446         }
1447         release_kbnode( keyblock );
1448
1449         if( !rc )
1450           {
1451             if(opt.verify_options&VERIFY_SHOW_POLICY)
1452               show_policy_url(sig,0,1);
1453             else
1454               show_policy_url(sig,0,2);
1455
1456             if(opt.verify_options&VERIFY_SHOW_NOTATION)
1457               show_notation(sig,0,1);
1458             else
1459               show_notation(sig,0,2);
1460           }
1461
1462         if( !rc && is_status_enabled() ) {
1463             /* print a status response with the fingerprint */
1464             PKT_public_key *vpk = m_alloc_clear( sizeof *vpk );
1465
1466             if( !get_pubkey( vpk, sig->keyid ) ) {
1467                 byte array[MAX_FINGERPRINT_LEN], *p;
1468                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1469                 size_t i, n;
1470
1471                 bufp = buf;
1472                 fingerprint_from_pk( vpk, array, &n );
1473                 p = array;
1474                 for(i=0; i < n ; i++, p++, bufp += 2)
1475                     sprintf(bufp, "%02X", *p );
1476                 /* TODO: Replace the reserved '0' in the field below
1477                    with bits for status flags (policy url, notation,
1478                    etc.).  Remember to make the buffer larger to
1479                    match! */
1480                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1481                         strtimestamp( sig->timestamp ),
1482                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1483                         sig->version,sig->pubkey_algo,sig->digest_algo,
1484                         sig->sig_class);
1485                 bufp = bufp + strlen (bufp);
1486                 if (!vpk->is_primary) {
1487                    u32 akid[2];
1488  
1489                    akid[0] = vpk->main_keyid[0];
1490                    akid[1] = vpk->main_keyid[1];
1491                    free_public_key (vpk);
1492                    vpk = m_alloc_clear( sizeof *vpk );
1493                    if (get_pubkey (vpk, akid)) {
1494                      /* impossible error, we simply return a zeroed out fpr */
1495                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1496                      memset (array, 0, n);
1497                    }
1498                    else
1499                      fingerprint_from_pk( vpk, array, &n );
1500                 }
1501                 p = array;
1502                 for(i=0; i < n ; i++, p++, bufp += 2)
1503                     sprintf(bufp, "%02X", *p );
1504                 write_status_text( STATUS_VALIDSIG, buf );
1505             }
1506             free_public_key( vpk );
1507         }
1508
1509         if( !rc )
1510             rc = check_signatures_trust( sig );
1511
1512         if(sig->flags.expired)
1513           {
1514             log_info(_("Signature expired %s\n"),
1515                      asctimestamp(sig->expiredate));
1516             rc=G10ERR_GENERAL; /* need a better error here? */
1517           }
1518         else if(sig->expiredate)
1519           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1520
1521         if(opt.verbose)
1522           log_info(_("%s signature, digest algorithm %s\n"),
1523                    sig->sig_class==0x00?_("binary"):
1524                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1525                    digest_algo_to_string(sig->digest_algo));
1526
1527         if( rc )
1528             g10_errors_seen = 1;
1529         if( opt.batch && rc )
1530             g10_exit(1);
1531     }
1532     else {
1533         char buf[50];
1534         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1535                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1536                      sig->pubkey_algo, sig->digest_algo,
1537                      sig->sig_class, (ulong)sig->timestamp, rc );
1538         write_status_text( STATUS_ERRSIG, buf );
1539         if( rc == G10ERR_NO_PUBKEY ) {
1540             buf[16] = 0;
1541             write_status_text( STATUS_NO_PUBKEY, buf );
1542         }
1543         if( rc != G10ERR_NOT_PROCESSED )
1544             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1545     }
1546     return rc;
1547 }
1548
1549
1550 /****************
1551  * Process the tree which starts at node
1552  */
1553 static void
1554 proc_tree( CTX c, KBNODE node )
1555 {
1556     KBNODE n1;
1557     int rc;
1558
1559     if( opt.list_packets || opt.list_only )
1560         return;
1561
1562     /* we must skip our special plaintext marker packets here becuase
1563        they may be the root packet.  These packets are only used in
1564        addionla checks and skipping them here doesn't matter */
1565     while ( node
1566             && node->pkt->pkttype == PKT_GPG_CONTROL
1567             && node->pkt->pkt.gpg_control->control
1568                          == CTRLPKT_PLAINTEXT_MARK ) {
1569         node = node->next;
1570     }
1571     if (!node)
1572         return;
1573
1574     c->local_id = 0;
1575     c->trustletter = ' ';
1576     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1577         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1578         merge_keys_and_selfsig( node );
1579         list_node( c, node );
1580     }
1581     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1582         merge_keys_and_selfsig( node );
1583         list_node( c, node );
1584     }
1585     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1586         /* check all signatures */
1587         if( !c->have_data ) {
1588             free_md_filter_context( &c->mfx );
1589             /* prepare to create all requested message digests */
1590             c->mfx.md = md_open(0, 0);
1591
1592             /* fixme: why looking for the signature packet and not 1passpacket*/
1593             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1594                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1595             }
1596             /* ask for file and hash it */
1597             if( c->sigs_only ) {
1598                 rc = hash_datafiles( c->mfx.md, NULL,
1599                                      c->signed_data, c->sigfilename,
1600                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1601             }
1602             else {
1603                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1604                                                 iobuf_get_real_fname(c->iobuf),
1605                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1606             }
1607             if( rc ) {
1608                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1609                 return;
1610             }
1611         }
1612         else if ( c->signed_data ) {
1613             log_error (_("not a detached signature\n") );
1614             return;
1615         }
1616
1617         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1618             check_sig_and_print( c, n1 );
1619     }
1620     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1621              && node->pkt->pkt.gpg_control->control
1622                 == CTRLPKT_CLEARSIGN_START ) {
1623         /* clear text signed message */
1624         if( !c->have_data ) {
1625             log_error("cleartext signature without data\n" );
1626             return;
1627         }
1628         else if ( c->signed_data ) {
1629             log_error (_("not a detached signature\n") );
1630             return;
1631         }
1632         
1633         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1634             check_sig_and_print( c, n1 );
1635     }
1636     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1637         PKT_signature *sig = node->pkt->pkt.signature;
1638         int multiple_ok=1;
1639
1640         n1=find_next_kbnode(node, PKT_SIGNATURE);
1641         if(n1)
1642           {
1643             byte class=sig->sig_class;
1644             byte hash=sig->digest_algo;
1645
1646             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1647               {
1648                 /* We can't currently handle multiple signatures of
1649                    different classes or digests (we'd pretty much have
1650                    to run a different hash context for each), but if
1651                    they are all the same, make an exception. */
1652                 if(n1->pkt->pkt.signature->sig_class!=class
1653                    || n1->pkt->pkt.signature->digest_algo!=hash)
1654                   {
1655                     multiple_ok=0;
1656                     log_info(_("WARNING: multiple signatures detected.  "
1657                                "Only the first will be checked.\n"));
1658                     break;
1659                   }
1660               }
1661           }
1662
1663         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
1664             log_info(_("standalone signature of class 0x%02x\n"),
1665                                                     sig->sig_class);
1666         else if( !c->have_data ) {
1667             /* detached signature */
1668             free_md_filter_context( &c->mfx );
1669             c->mfx.md = md_open(sig->digest_algo, 0);
1670             if( !opt.pgp2_workarounds )
1671                 ;
1672             else if( sig->digest_algo == DIGEST_ALGO_MD5
1673                      && is_RSA( sig->pubkey_algo ) ) {
1674                 /* enable a workaround for a pgp2 bug */
1675                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1676             }
1677             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1678                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1679                      && sig->sig_class == 0x01 ) {
1680                 /* enable the workaround also for pgp5 when the detached
1681                  * signature has been created in textmode */
1682                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1683             }
1684 #if 0 /* workaround disabled */
1685             /* Here we have another hack to work around a pgp 2 bug
1686              * It works by not using the textmode for detached signatures;
1687              * this will let the first signature check (on md) fail
1688              * but the second one (on md2) which adds an extra CR should
1689              * then produce the "correct" hash.  This is very, very ugly
1690              * hack but it may help in some cases (and break others)
1691              */
1692                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
1693 #endif
1694             if ( DBG_HASHING ) {
1695                 md_start_debug( c->mfx.md, "verify" );
1696                 if ( c->mfx.md2  )
1697                     md_start_debug( c->mfx.md2, "verify2" );
1698             }
1699             if( c->sigs_only ) {
1700                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
1701                                      c->signed_data, c->sigfilename,
1702                                      (sig->sig_class == 0x01) );
1703             }
1704             else {
1705                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1706                                                 iobuf_get_real_fname(c->iobuf),
1707                                                 (sig->sig_class == 0x01) );
1708             }
1709             if( rc ) {
1710                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1711                 return;
1712             }
1713         }
1714         else if ( c->signed_data ) {
1715             log_error (_("not a detached signature\n") );
1716             return;
1717         }
1718         else if ( c->pipemode.op == 'B' )
1719             ; /* this is a detached signature trough the pipemode handler */
1720         else if (!opt.quiet)
1721             log_info(_("old style (PGP 2.x) signature\n"));
1722
1723         if(multiple_ok)
1724           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
1725             check_sig_and_print( c, n1 );
1726         else
1727           check_sig_and_print( c, node );
1728     }
1729     else {
1730         dump_kbnode (c->list);
1731         log_error(_("invalid root packet detected in proc_tree()\n"));
1732         dump_kbnode (node);
1733     }
1734 }