896120e86e31b31c2766fba8cb59a20fdac11d6e
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle packets
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 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"), slen);
249         return;   
250     }
251     hd = cipher_open( dek->algo, CIPHER_MODE_CFB, 1 );
252     cipher_setkey( hd, dek->key, dek->keylen );
253     cipher_setiv( hd, NULL, 0 );
254     cipher_decrypt( hd, sesskey, sesskey, slen );
255     cipher_close( hd );
256     /* check first byte (the cipher algo) */
257     if ( sesskey[0] > 10 ) {
258         log_error ( _("invalid symkey algorithm detected (%d)\n"),
259                     sesskey[0] );
260         return;
261     }
262     n = cipher_get_keylen (sesskey[0]) / 8;
263     if (n > DIM(dek->key))
264          BUG ();
265     /* now we replace the dek components with the real session key
266        to decrypt the contents of the sequencing packet. */
267     dek->keylen = cipher_get_keylen( sesskey[0] ) / 8;
268     dek->algo = sesskey[0];
269     memcpy( dek->key, sesskey + 1, dek->keylen );
270     /*log_hexdump( "thekey", dek->key, dek->keylen );*/
271 }   
272
273 static void
274 proc_symkey_enc( CTX c, PACKET *pkt )
275 {
276     PKT_symkey_enc *enc;
277
278     enc = pkt->pkt.symkey_enc;
279     if (!enc)
280         log_error ("invalid symkey encrypted packet\n");
281     else {
282         int algo = enc->cipher_algo;
283         const char *s;
284
285         s = cipher_algo_to_string (algo);
286         if( s )
287             log_info(_("%s encrypted data\n"), s );
288         else
289             log_info(_("encrypted with unknown algorithm %d\n"), algo );
290
291         c->last_was_session_key = 2;
292         if ( opt.list_only )
293             goto leave;
294         c->dek = passphrase_to_dek( NULL, 0, algo, &enc->s2k, 0, NULL );
295         if (c->dek)
296             c->dek->algo_info_printed = 1;
297         if ( c->dek && enc->seskeylen )
298             symkey_decrypt_sesskey( c->dek, enc->seskey, enc->seskeylen );
299     }
300 leave:
301     free_packet(pkt);
302 }
303
304 static void
305 proc_pubkey_enc( CTX c, PACKET *pkt )
306 {
307     PKT_pubkey_enc *enc;
308     int result = 0;
309
310     /* check whether the secret key is available and store in this case */
311     c->last_was_session_key = 1;
312     enc = pkt->pkt.pubkey_enc;
313     /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
314     /* Hmmm: why do I have this algo check here - anyway there is
315      * function to check it. */
316     if( opt.verbose )
317         log_info(_("public key is %08lX\n"), (ulong)enc->keyid[1] );
318
319     if( is_status_enabled() ) {
320         char buf[50];
321         sprintf(buf, "%08lX%08lX %d 0",
322                 (ulong)enc->keyid[0], (ulong)enc->keyid[1], enc->pubkey_algo );
323         write_status_text( STATUS_ENC_TO, buf );
324     }
325
326     if( !opt.list_only && opt.override_session_key ) {
327         /* It does not make much sense to store the session key in
328          * secure memory because it has already been passed on the
329          * command line and the GCHQ knows about it */
330         c->dek = m_alloc_clear( sizeof *c->dek );
331         result = get_override_session_key ( c->dek, opt.override_session_key );
332         if ( result ) {
333             m_free(c->dek); c->dek = NULL;
334         }
335     }
336     else if( is_ELGAMAL(enc->pubkey_algo)
337         || enc->pubkey_algo == PUBKEY_ALGO_DSA
338         || is_RSA(enc->pubkey_algo)  ) {
339         if ( !c->dek && ((!enc->keyid[0] && !enc->keyid[1])
340                           || opt.try_all_secrets
341                           || !seckey_available( enc->keyid )) ) {
342             if( opt.list_only )
343                 result = -1;
344             else {
345                 c->dek = m_alloc_secure_clear( sizeof *c->dek );
346                 if( (result = get_session_key( enc, c->dek )) ) {
347                     /* error: delete the DEK */
348                     m_free(c->dek); c->dek = NULL;
349                 }
350             }
351         }
352         else
353             result = G10ERR_NO_SECKEY;
354     }
355     else
356         result = G10ERR_PUBKEY_ALGO;
357
358     if( result == -1 )
359         ;
360     else {
361         if( !result ) {
362             if( opt.verbose > 1 )
363                 log_info( _("public key encrypted data: good DEK\n") );
364             if ( opt.show_session_key ) {
365                 int i;
366                 char *buf = m_alloc ( c->dek->keylen*2 + 20 );
367                 sprintf ( buf, "%d:", c->dek->algo );
368                 for(i=0; i < c->dek->keylen; i++ )
369                     sprintf(buf+strlen(buf), "%02X", c->dek->key[i] );
370                 log_info( "session key: \"%s\"\n", buf );
371                 write_status_text ( STATUS_SESSION_KEY, buf );
372             }
373         }
374         /* store it for later display */
375         {
376             struct kidlist_item *x = m_alloc( sizeof *x );
377             x->kid[0] = enc->keyid[0];
378             x->kid[1] = enc->keyid[1];
379             x->pubkey_algo = enc->pubkey_algo;
380             x->reason = result;
381             x->next = c->pkenc_list;
382             c->pkenc_list = x;
383         }
384     }
385     free_packet(pkt);
386 }
387
388
389
390 /****************
391  * Print the list of public key encrypted packets which we could
392  * not decrypt.
393  */
394 static void
395 print_pkenc_list( struct kidlist_item *list, int failed )
396 {
397     for( ; list; list = list->next ) {
398         PKT_public_key *pk;
399         const char *algstr;
400         
401         if ( failed && !list->reason )
402             continue;
403         if ( !failed && list->reason )
404             continue;
405
406         algstr = pubkey_algo_to_string( list->pubkey_algo );
407         pk = m_alloc_clear( sizeof *pk );
408
409         if( !algstr )
410             algstr = "[?]";
411         pk->pubkey_algo = list->pubkey_algo;
412         if( !get_pubkey( pk, list->kid ) ) {
413             size_t n;
414             char *p;
415             log_info( _("encrypted with %u-bit %s key, ID %08lX, created %s\n"),
416                        nbits_from_pk( pk ), algstr, (ulong)list->kid[1],
417                        strtimestamp(pk->timestamp) );
418             fputs("      \"", log_stream() );
419             p = get_user_id( list->kid, &n );
420             print_utf8_string2 ( log_stream(), p, n, '"' );
421             m_free(p);
422             fputs("\"\n", log_stream() );
423         }
424         else {
425             log_info(_("encrypted with %s key, ID %08lX\n"),
426                         algstr, (ulong) list->kid[1] );
427         }
428         free_public_key( pk );
429
430         if( list->reason == G10ERR_NO_SECKEY ) {
431             if( is_status_enabled() ) {
432                 char buf[20];
433                 sprintf(buf,"%08lX%08lX", (ulong)list->kid[0],
434                                           (ulong)list->kid[1] );
435                 write_status_text( STATUS_NO_SECKEY, buf );
436             }
437         }
438         else if (list->reason)
439             log_info(_("public key decryption failed: %s\n"),
440                                                 g10_errstr(list->reason));
441     }
442 }
443
444
445 static void
446 proc_encrypted( CTX c, PACKET *pkt )
447 {
448     int result = 0;
449
450     if (!opt.quiet) {
451         print_pkenc_list ( c->pkenc_list, 1 );
452         print_pkenc_list ( c->pkenc_list, 0 );
453     }
454
455     write_status( STATUS_BEGIN_DECRYPTION );
456
457     /*log_debug("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
458     if( opt.list_only )
459         result = -1;
460     else if( !c->dek && !c->last_was_session_key ) {
461         int algo;
462         STRING2KEY s2kbuf, *s2k = NULL;
463
464         /* assume this is old style conventional encrypted data */
465         if ( (algo = opt.def_cipher_algo))
466             log_info (_("assuming %s encrypted data\n"),
467                         cipher_algo_to_string(algo));
468         else if ( check_cipher_algo(CIPHER_ALGO_IDEA) ) {
469             algo = opt.def_cipher_algo;
470             if (!algo)
471                 algo = opt.s2k_cipher_algo;
472             idea_cipher_warn(1);
473             log_info (_("IDEA cipher unavailable, "
474                         "optimistically attempting to use %s instead\n"),
475                        cipher_algo_to_string(algo));
476         }
477         else {
478             algo = CIPHER_ALGO_IDEA;
479             if (!opt.def_digest_algo) {
480                 /* If no digest is given we assume MD5 */
481                 s2kbuf.mode = 0;
482                 s2kbuf.hash_algo = DIGEST_ALGO_MD5;
483                 s2k = &s2kbuf;
484             }
485             log_info (_("assuming %s encrypted data\n"), "IDEA");
486         }
487
488         c->dek = passphrase_to_dek ( NULL, 0, algo, s2k, 0, NULL );
489         if (c->dek)
490             c->dek->algo_info_printed = 1;
491     }
492     else if( !c->dek )
493         result = G10ERR_NO_SECKEY;
494     if( !result )
495         result = decrypt_data( c, pkt->pkt.encrypted, c->dek );
496
497     m_free(c->dek); c->dek = NULL;
498     if( result == -1 )
499         ;
500     else if( !result || (result==G10ERR_BAD_SIGN && opt.ignore_mdc_error)) {
501         write_status( STATUS_DECRYPTION_OKAY );
502         if( opt.verbose > 1 )
503             log_info(_("decryption okay\n"));
504         if( pkt->pkt.encrypted->mdc_method && !result )
505             write_status( STATUS_GOODMDC );
506         else if(!opt.no_mdc_warn)
507             log_info ("WARNING: message was not integrity protected\n");
508     }
509     else if( result == G10ERR_BAD_SIGN ) {
510         log_error(_("WARNING: encrypted message has been manipulated!\n"));
511         write_status( STATUS_BADMDC );
512         write_status( STATUS_DECRYPTION_FAILED );
513     }
514     else {
515         write_status( STATUS_DECRYPTION_FAILED );
516         log_error(_("decryption failed: %s\n"), g10_errstr(result));
517         /* Hmmm: does this work when we have encrypted using multiple
518          * ways to specify the session key (symmmetric and PK)*/
519     }
520     free_packet(pkt);
521     c->last_was_session_key = 0;
522     write_status( STATUS_END_DECRYPTION );
523 }
524
525
526
527 static void
528 proc_plaintext( CTX c, PACKET *pkt )
529 {
530     PKT_plaintext *pt = pkt->pkt.plaintext;
531     int any, clearsig, only_md5, rc;
532     KBNODE n;
533
534     if( pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8 ) )
535         log_info(_("NOTE: sender requested \"for-your-eyes-only\"\n"));
536     else if( opt.verbose )
537         log_info(_("original file name='%.*s'\n"), pt->namelen, pt->name);
538     free_md_filter_context( &c->mfx );
539     c->mfx.md = md_open( 0, 0);
540     /* fixme: we may need to push the textfilter if we have sigclass 1
541      * and no armoring - Not yet tested
542      * Hmmm, why don't we need it at all if we have sigclass 1
543      * Should we assume that plaintext in mode 't' has always sigclass 1??
544      * See: Russ Allbery's mail 1999-02-09
545      */
546     any = clearsig = only_md5 = 0;
547     for(n=c->list; n; n = n->next ) {
548         if( n->pkt->pkttype == PKT_ONEPASS_SIG ) {
549             if( n->pkt->pkt.onepass_sig->digest_algo ) {
550                 md_enable( c->mfx.md, n->pkt->pkt.onepass_sig->digest_algo );
551                 if( !any && n->pkt->pkt.onepass_sig->digest_algo
552                                                       == DIGEST_ALGO_MD5 )
553                     only_md5 = 1;
554                 else
555                     only_md5 = 0;
556                 any = 1;
557             }
558             if( n->pkt->pkt.onepass_sig->sig_class != 0x01 )
559                 only_md5 = 0;
560         }
561         else if( n->pkt->pkttype == PKT_GPG_CONTROL
562                  && n->pkt->pkt.gpg_control->control
563                     == CTRLPKT_CLEARSIGN_START ) {
564             size_t datalen = n->pkt->pkt.gpg_control->datalen;
565             const byte *data = n->pkt->pkt.gpg_control->data;
566
567             /* check that we have at least the sigclass and one hash */
568             if ( datalen < 2 )
569                 log_fatal("invalid control packet CTRLPKT_CLEARSIGN_START\n"); 
570             /* Note that we don't set the clearsig flag for not-dash-escaped
571              * documents */
572             clearsig = (*data == 0x01);
573             for( data++, datalen--; datalen; datalen--, data++ )
574                 md_enable( c->mfx.md, *data );
575             any = 1;
576             break;  /* no pass signature pakets are expected */
577         }
578     }
579
580     if( !any && !opt.skip_verify ) {
581         /* no onepass sig packet: enable all standard algos */
582         md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
583         md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
584         md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
585     }
586     if( opt.pgp2_workarounds && only_md5 && !opt.skip_verify ) {
587         /* This is a kludge to work around a bug in pgp2.  It does only
588          * catch those mails which are armored.  To catch the non-armored
589          * pgp mails we could see whether there is the signature packet
590          * in front of the plaintext.  If someone needs this, send me a patch.
591          */
592         c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0);
593     }
594     if ( DBG_HASHING ) {
595         md_start_debug( c->mfx.md, "verify" );
596         if ( c->mfx.md2  )
597             md_start_debug( c->mfx.md2, "verify2" );
598     }
599     if ( c->pipemode.op == 'B' )
600         rc = handle_plaintext( pt, &c->mfx, 1, 0 );
601     else {
602         rc = handle_plaintext( pt, &c->mfx, c->sigs_only, clearsig );
603         if( rc == G10ERR_CREATE_FILE && !c->sigs_only) {
604             /* can't write output but we hash it anyway to
605              * check the signature */
606             rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
607         }
608     }
609     if( rc )
610         log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
611     free_packet(pkt);
612     c->last_was_session_key = 0;
613
614     /* We add a marker control packet instead of the plaintext packet.
615      * This is so that we can later detect invalid packet sequences.
616      */
617     n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
618     if (c->list)
619         add_kbnode (c->list, n);
620     else 
621         c->list = n;
622 }
623
624
625 static int
626 proc_compressed_cb( IOBUF a, void *info )
627 {
628     return proc_signature_packets( info, a, ((CTX)info)->signed_data,
629                                             ((CTX)info)->sigfilename );
630 }
631
632 static int
633 proc_encrypt_cb( IOBUF a, void *info )
634 {
635     return proc_encryption_packets( info, a );
636 }
637
638 static void
639 proc_compressed( CTX c, PACKET *pkt )
640 {
641     PKT_compressed *zd = pkt->pkt.compressed;
642     int rc;
643
644     /*printf("zip: compressed data packet\n");*/
645     if( c->sigs_only )
646         rc = handle_compressed( c, zd, proc_compressed_cb, c );
647     else if( c->encrypt_only )
648         rc = handle_compressed( c, zd, proc_encrypt_cb, c );
649     else
650         rc = handle_compressed( c, zd, NULL, NULL );
651     if( rc )
652         log_error("uncompressing failed: %s\n", g10_errstr(rc));
653     free_packet(pkt);
654     c->last_was_session_key = 0;
655 }
656
657 /****************
658  * check the signature
659  * Returns: 0 = valid signature or an error code
660  */
661 static int
662 do_check_sig( CTX c, KBNODE node, int *is_selfsig, int *is_expkey )
663 {
664     PKT_signature *sig;
665     MD_HANDLE md = NULL, md2 = NULL;
666     int algo, rc, dum2;
667     u32 dummy;
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, &dummy, is_expkey );
725     if( rc == G10ERR_BAD_SIGN && md2 )
726         rc = signature_check2( sig, md2, &dummy, is_expkey );
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 static void
760 print_notation_data( PKT_signature *sig )
761 {
762     size_t n, n1, n2;
763     const byte *p;
764     int seq = 0;
765
766     while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&n,&seq,NULL))) {
767         if( n < 8 ) {
768             log_info(_("WARNING: invalid notation data found\n"));
769             return;
770         }
771         if( !(*p & 0x80) )
772             return; /* not human readable */
773         n1 = (p[4] << 8) | p[5];
774         n2 = (p[6] << 8) | p[7];
775         p += 8;
776         if( 8+n1+n2 != n ) {
777             log_info(_("WARNING: invalid notation data found\n"));
778             return;
779         }
780         log_info(_("Notation: ") );
781         print_string( log_stream(), p, n1, 0 );
782         putc( '=', log_stream() );
783         print_string( log_stream(), p+n1, n2, 0 );
784         putc( '\n', log_stream() );
785         write_status_buffer ( STATUS_NOTATION_NAME, p   , n1, 0 );
786         write_status_buffer ( STATUS_NOTATION_DATA, p+n1, n2, 50 );
787     }
788
789     seq=0;
790
791     while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_POLICY,&n,&seq,NULL))) {
792         log_info(_("Policy: ") );
793         print_string( log_stream(), p, n, 0 );
794         putc( '\n', log_stream() );
795         write_status_buffer ( STATUS_POLICY_URL, p, n, 0 );
796     }
797
798     /* Now check whether the key of this signature has some
799      * notation data */
800
801     /* TODO */
802 }
803
804
805 /****************
806  * List the certificate in a user friendly way
807  */
808
809 static void
810 list_node( CTX c, KBNODE node )
811 {
812     int any=0;
813     int mainkey;
814
815     if( !node )
816         ;
817     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
818              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
819         PKT_public_key *pk = node->pkt->pkt.public_key;
820
821         if( opt.with_colons ) {
822             u32 keyid[2];
823             keyid_from_pk( pk, keyid );
824             if( mainkey ) {
825                 c->local_id = pk->local_id;
826                 c->trustletter = opt.fast_list_mode?
827                                            0 : get_validity_info( pk, NULL );
828             }
829             printf("%s:", mainkey? "pub":"sub" );
830             if( c->trustletter )
831                 putchar( c->trustletter );
832             printf(":%u:%d:%08lX%08lX:%s:%s:",
833                     nbits_from_pk( pk ),
834                     pk->pubkey_algo,
835                     (ulong)keyid[0],(ulong)keyid[1],
836                     colon_datestr_from_pk( pk ),
837                     colon_strtime (pk->expiredate) );
838             if( c->local_id )
839                 printf("%lu", c->local_id );
840             putchar(':');
841             if( mainkey && !opt.fast_list_mode )
842                  putchar( get_ownertrust_info (pk) );
843             putchar(':');
844             if( node->next && node->next->pkt->pkttype == PKT_RING_TRUST) {
845                 putchar('\n'); any=1;
846                 if( opt.fingerprint )
847                     print_fingerprint( pk, NULL, 0 );
848                 printf("rtv:1:%u:\n",
849                             node->next->pkt->pkt.ring_trust->trustval );
850             }
851         }
852         else
853             printf("%s  %4u%c/%08lX %s ",
854                                       mainkey? "pub":"sub",
855                                       nbits_from_pk( pk ),
856                                       pubkey_letter( pk->pubkey_algo ),
857                                       (ulong)keyid_from_pk( pk, NULL ),
858                                       datestr_from_pk( pk )     );
859
860         if( mainkey ) {
861             /* and now list all userids with their signatures */
862             for( node = node->next; node; node = node->next ) {
863                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
864                     if( !any ) {
865                         if( node->pkt->pkt.signature->sig_class == 0x20 )
866                             puts("[revoked]");
867                         else
868                             putchar('\n');
869                         any = 1;
870                     }
871                     list_node(c,  node );
872                 }
873                 else if( node->pkt->pkttype == PKT_USER_ID ) {
874                     if( any ) {
875                         if( opt.with_colons )
876                             printf("%s:::::::::",
877                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
878                         else
879                             printf( "uid%*s", 28, "" );
880                     }
881                     print_userid( node->pkt );
882                     if( opt.with_colons )
883                         putchar(':');
884                     putchar('\n');
885                     if( opt.fingerprint && !any )
886                         print_fingerprint( pk, NULL, 0 );
887                     if( node->next
888                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
889                         printf("rtv:2:%u:\n",
890                                  node->next->pkt->pkt.ring_trust->trustval );
891                     }
892                     any=1;
893                 }
894                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
895                     if( !any ) {
896                         putchar('\n');
897                         any = 1;
898                     }
899                     list_node(c,  node );
900                 }
901             }
902         }
903         else if( pk->expiredate ) { /* of subkey */
904             printf(_(" [expires: %s]"), expirestr_from_pk( pk ) );
905         }
906
907         if( !any )
908             putchar('\n');
909         if( !mainkey && opt.fingerprint > 1 )
910             print_fingerprint( pk, NULL, 0 );
911     }
912     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
913              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
914         PKT_secret_key *sk = node->pkt->pkt.secret_key;
915
916         if( opt.with_colons ) {
917             u32 keyid[2];
918             keyid_from_sk( sk, keyid );
919             printf("%s::%u:%d:%08lX%08lX:%s:%s:::",
920                     mainkey? "sec":"ssb",
921                     nbits_from_sk( sk ),
922                     sk->pubkey_algo,
923                     (ulong)keyid[0],(ulong)keyid[1],
924                     colon_datestr_from_sk( sk ),
925                     colon_strtime (sk->expiredate)
926                     /* fixme: add LID */ );
927         }
928         else
929             printf("%s  %4u%c/%08lX %s ",
930                                       mainkey? "sec":"ssb",
931                                       nbits_from_sk( sk ),
932                                       pubkey_letter( sk->pubkey_algo ),
933                                       (ulong)keyid_from_sk( sk, NULL ),
934                                       datestr_from_sk( sk )   );
935         if( mainkey ) {
936             /* and now list all userids with their signatures */
937             for( node = node->next; node; node = node->next ) {
938                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
939                     if( !any ) {
940                         if( node->pkt->pkt.signature->sig_class == 0x20 )
941                             puts("[revoked]");
942                         else
943                             putchar('\n');
944                         any = 1;
945                     }
946                     list_node(c,  node );
947                 }
948                 else if( node->pkt->pkttype == PKT_USER_ID ) {
949                     if( any ) {
950                         if( opt.with_colons )
951                             printf("%s:::::::::",
952                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
953                         else
954                             printf( "uid%*s", 28, "" );
955                     }
956                     print_userid( node->pkt );
957                     if( opt.with_colons )
958                         putchar(':');
959                     putchar('\n');
960                     if( opt.fingerprint && !any )
961                         print_fingerprint( NULL, sk, 0 );
962                     any=1;
963                 }
964                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
965                     if( !any ) {
966                         putchar('\n');
967                         any = 1;
968                     }
969                     list_node(c,  node );
970                 }
971             }
972         }
973         if( !any )
974             putchar('\n');
975         if( !mainkey && opt.fingerprint > 1 )
976             print_fingerprint( NULL, sk, 0 );
977     }
978     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
979         PKT_signature *sig = node->pkt->pkt.signature;
980         int is_selfsig = 0;
981         int rc2=0;
982         size_t n;
983         char *p;
984         int sigrc = ' ';
985
986         if( !opt.list_sigs )
987             return;
988
989         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
990             fputs("rev", stdout);
991         else
992             fputs("sig", stdout);
993         if( opt.check_sigs ) {
994             fflush(stdout);
995             switch( (rc2=do_check_sig( c, node, &is_selfsig, NULL )) ) {
996               case 0:                  sigrc = '!'; break;
997               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
998               case G10ERR_NO_PUBKEY: 
999               case G10ERR_UNU_PUBKEY:  sigrc = '?'; break;
1000               default:                 sigrc = '%'; break;
1001             }
1002         }
1003         else {  /* check whether this is a self signature */
1004             u32 keyid[2];
1005
1006             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
1007                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
1008                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
1009                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
1010                 else
1011                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
1012
1013                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
1014                     is_selfsig = 1;
1015             }
1016         }
1017         if( opt.with_colons ) {
1018             putchar(':');
1019             if( sigrc != ' ' )
1020                 putchar(sigrc);
1021             printf("::%d:%08lX%08lX:%s::::", sig->pubkey_algo,
1022                                              (ulong)sig->keyid[0],
1023                        (ulong)sig->keyid[1], colon_datestr_from_sig(sig));
1024         }
1025         else
1026             printf("%c       %08lX %s   ",
1027                     sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
1028         if( sigrc == '%' )
1029             printf("[%s] ", g10_errstr(rc2) );
1030         else if( sigrc == '?' )
1031             ;
1032         else if( is_selfsig ) {
1033             if( opt.with_colons )
1034                 putchar(':');
1035             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
1036             if( opt.with_colons )
1037                 putchar(':');
1038         }
1039         else if( !opt.fast_list_mode ) {
1040             p = get_user_id( sig->keyid, &n );
1041             print_string( stdout, p, n, opt.with_colons );
1042             m_free(p);
1043         }
1044         if( opt.with_colons )
1045             printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1046         putchar('\n');
1047     }
1048     else
1049         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
1050 }
1051
1052
1053
1054 int
1055 proc_packets( void *anchor, IOBUF a )
1056 {
1057     int rc;
1058     CTX c = m_alloc_clear( sizeof *c );
1059
1060     c->anchor = anchor;
1061     rc = do_proc_packets( c, a );
1062     m_free( c );
1063     return rc;
1064 }
1065
1066
1067
1068 int
1069 proc_signature_packets( void *anchor, IOBUF a,
1070                         STRLIST signedfiles, const char *sigfilename )
1071 {
1072     CTX c = m_alloc_clear( sizeof *c );
1073     int rc;
1074
1075     c->anchor = anchor;
1076     c->sigs_only = 1;
1077     c->signed_data = signedfiles;
1078     c->sigfilename = sigfilename;
1079     rc = do_proc_packets( c, a );
1080     m_free( c );
1081     return rc;
1082 }
1083
1084 int
1085 proc_encryption_packets( void *anchor, IOBUF a )
1086 {
1087     CTX c = m_alloc_clear( sizeof *c );
1088     int rc;
1089
1090     c->anchor = anchor;
1091     c->encrypt_only = 1;
1092     rc = do_proc_packets( c, a );
1093     m_free( c );
1094     return rc;
1095 }
1096
1097
1098 int
1099 do_proc_packets( CTX c, IOBUF a )
1100 {
1101     PACKET *pkt = m_alloc( sizeof *pkt );
1102     int rc=0;
1103     int any_data=0;
1104     int newpkt;
1105
1106     c->iobuf = a;
1107     init_packet(pkt);
1108     while( (rc=parse_packet(a, pkt)) != -1 ) {
1109         any_data = 1;
1110         if( rc ) {
1111             free_packet(pkt);
1112             /* stop processing hwne an invalid packet has been encountered
1113              * but don't do so when we are doing a --list-packet. */
1114             if( rc == G10ERR_INVALID_PACKET && opt.list_packets != 2 )
1115                 break;
1116             continue;
1117         }
1118         newpkt = -1;
1119         if( opt.list_packets ) {
1120             switch( pkt->pkttype ) {
1121               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1122               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1123               case PKT_ENCRYPTED:
1124               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1125               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1126               default: newpkt = 0; break;
1127             }
1128         }
1129         else if( c->sigs_only ) {
1130             switch( pkt->pkttype ) {
1131               case PKT_PUBLIC_KEY:
1132               case PKT_SECRET_KEY:
1133               case PKT_USER_ID:
1134               case PKT_SYMKEY_ENC:
1135               case PKT_PUBKEY_ENC:
1136               case PKT_ENCRYPTED:
1137               case PKT_ENCRYPTED_MDC:
1138                 write_status_text( STATUS_UNEXPECTED, "0" );
1139                 rc = G10ERR_UNEXPECTED;
1140                 goto leave;
1141               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1142               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1143               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1144               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1145               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1146               default: newpkt = 0; break;
1147             }
1148         }
1149         else if( c->encrypt_only ) {
1150             switch( pkt->pkttype ) {
1151               case PKT_PUBLIC_KEY:
1152               case PKT_SECRET_KEY:
1153               case PKT_USER_ID:
1154                 write_status_text( STATUS_UNEXPECTED, "0" );
1155                 rc = G10ERR_UNEXPECTED;
1156                 goto leave;
1157               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1158               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1159               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1160               case PKT_ENCRYPTED:
1161               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1162               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1163               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1164               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1165               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1166               default: newpkt = 0; break;
1167             }
1168         }
1169         else {
1170             switch( pkt->pkttype ) {
1171               case PKT_PUBLIC_KEY:
1172               case PKT_SECRET_KEY:
1173                 release_list( c );
1174                 c->list = new_kbnode( pkt );
1175                 newpkt = 1;
1176                 break;
1177               case PKT_PUBLIC_SUBKEY:
1178               case PKT_SECRET_SUBKEY:
1179                 newpkt = add_subkey( c, pkt );
1180                 break;
1181               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1182               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1183               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1184               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1185               case PKT_ENCRYPTED:
1186               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1187               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1188               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1189               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1190               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1191               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1192               default: newpkt = 0; break;
1193             }
1194         }
1195         /* This is a very ugly construct and frankly, I don't remember why
1196          * I used it.  Adding the MDC check here is a hack.
1197          * The right solution is to initiate another context for encrypted
1198          * packet and not to reuse the current one ...  It works right
1199          * when there is a compression packet inbetween which adds just
1200          * an extra layer.
1201          * Hmmm: Rewrite this whole module here?? 
1202          */
1203         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1204             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
1205
1206         if( newpkt == -1 )
1207             ;
1208         else if( newpkt ) {
1209             pkt = m_alloc( sizeof *pkt );
1210             init_packet(pkt);
1211         }
1212         else
1213             free_packet(pkt);
1214         if ( c->pipemode.stop_now ) {
1215             /* we won't get an EOF in pipemode, so we have to 
1216              * break the loop here */ 
1217             rc = -1;
1218             break;
1219         }
1220     }
1221     if( rc == G10ERR_INVALID_PACKET )
1222         write_status_text( STATUS_NODATA, "3" );
1223     if( any_data )
1224         rc = 0;
1225     else if( rc == -1 )
1226         write_status_text( STATUS_NODATA, "2" );
1227
1228
1229   leave:
1230     release_list( c );
1231     m_free(c->dek);
1232     free_packet( pkt );
1233     m_free( pkt );
1234     free_md_filter_context( &c->mfx );
1235     return rc;
1236 }
1237
1238
1239 static int
1240 check_sig_and_print( CTX c, KBNODE node )
1241 {
1242     PKT_signature *sig = node->pkt->pkt.signature;
1243     const char *astr, *tstr;
1244     int rc, is_expkey=0;
1245
1246     if( opt.skip_verify ) {
1247         log_info(_("signature verification suppressed\n"));
1248         return 0;
1249     }
1250
1251     /* It is not in all cases possible to check multiple signatures:
1252      * PGP 2 (which is also allowed by OpenPGP), does use the packet
1253      * sequence: sig+data,  OpenPGP does use onepas+data=sig and GnuPG
1254      * sometimes uses (because I did'nt read the specs right) data+sig.
1255      * Because it is possible to create multiple signatures with
1256      * different packet sequence (e.g. data+sig and sig+data) it might
1257      * not be possible to get it right:  let's say we have:
1258      * data+sig, sig+data,sig+data and we have not yet encountered the last
1259      * data, we could also see this a one data with 2 signatures and then 
1260      * data+sig.
1261      * To protect against this we check that all signatures follow
1262      * without any intermediate packets.  Note, that we won't get this
1263      * error when we use onepass packets or cleartext signatures because
1264      * we reset the list every time
1265      *
1266      * FIXME: Now that we have these marker packets, we should create a 
1267      * real grammar and check against this.
1268      */
1269     {
1270         KBNODE n;
1271         int n_sig=0;
1272
1273         for (n=c->list; n; n=n->next ) {
1274             if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1275                 n_sig++;
1276         }
1277         if (n_sig > 1) { /* more than one signature - check sequence */
1278             int tmp, onepass;
1279
1280             for (tmp=onepass=0,n=c->list; n; n=n->next ) {
1281                 if (n->pkt->pkttype == PKT_ONEPASS_SIG) 
1282                     onepass++;
1283                 else if (n->pkt->pkttype == PKT_GPG_CONTROL
1284                          && n->pkt->pkt.gpg_control->control
1285                             == CTRLPKT_CLEARSIGN_START ) {
1286                     onepass++; /* handle the same way as a onepass */
1287                 }
1288                 else if ( (tmp && n->pkt->pkttype != PKT_SIGNATURE) ) {
1289                     log_error(_("can't handle these multiple signatures\n"));
1290                     return 0;
1291                 }
1292                 else if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1293                     tmp = 1;
1294                 else if (!tmp && !onepass 
1295                          && n->pkt->pkttype == PKT_GPG_CONTROL
1296                          && n->pkt->pkt.gpg_control->control
1297                             == CTRLPKT_PLAINTEXT_MARK ) {
1298                     /* plaintext before signatures but no one-pass packets*/
1299                     log_error(_("can't handle these multiple signatures\n"));
1300                     return 0;
1301                 }
1302             }
1303         }
1304     }
1305     
1306
1307
1308     tstr = asctimestamp(sig->timestamp);
1309     astr = pubkey_algo_to_string( sig->pubkey_algo );
1310     log_info(_("Signature made %.*s using %s key ID %08lX\n"),
1311             (int)strlen(tstr), tstr, astr? astr: "?", (ulong)sig->keyid[1] );
1312
1313     rc = do_check_sig(c, node, NULL, &is_expkey );
1314     if( rc == G10ERR_NO_PUBKEY && opt.keyserver_scheme && opt.keyserver_options.auto_key_retrieve) {
1315         if( keyserver_import_keyid ( sig->keyid )==0 )
1316             rc = do_check_sig(c, node, NULL, &is_expkey );
1317     }
1318     if( !rc || rc == G10ERR_BAD_SIGN ) {
1319         KBNODE un, keyblock;
1320         int count=0, statno;
1321         char keyid_str[50];
1322
1323         if(rc)
1324           statno=STATUS_BADSIG;
1325         else if(sig->flags.expired)
1326           statno=STATUS_EXPSIG;
1327         else if(is_expkey)
1328           statno=STATUS_EXPKEYSIG;
1329         else
1330           statno=STATUS_GOODSIG;
1331
1332         keyblock = get_pubkeyblock( sig->keyid );
1333
1334         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1335                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1336
1337         /* find and print the primary user ID */
1338         for( un=keyblock; un; un = un->next ) {
1339             if( un->pkt->pkttype != PKT_USER_ID )
1340                 continue;
1341             if ( !un->pkt->pkt.user_id->created )
1342                 continue;
1343             if ( un->pkt->pkt.user_id->is_revoked )
1344                 continue;
1345             if ( un->pkt->pkt.user_id->is_expired )
1346                 continue;
1347             if ( !un->pkt->pkt.user_id->is_primary )
1348                 continue;
1349             /* We want the textual user ID here */
1350             if ( un->pkt->pkt.user_id->attrib_data )
1351                 continue;
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             fputs("\"\n", log_stream() );
1365             count++;
1366         }
1367         if( !count ) {  /* just in case that we have no valid textual
1368                            userid */
1369             /* Try for an invalid textual userid */
1370             for( un=keyblock; un; un = un->next ) {
1371                 if( un->pkt->pkttype == PKT_USER_ID &&
1372                     !un->pkt->pkt.user_id->attrib_data )
1373                     break;
1374             }
1375
1376             /* Try for any userid at all */
1377             if(!un) {
1378                 for( un=keyblock; un; un = un->next ) {
1379                     if( un->pkt->pkttype == PKT_USER_ID )
1380                         break;
1381                 }
1382             }
1383
1384             if (opt.always_trust || !un)
1385                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1386
1387             write_status_text_and_buffer (statno, keyid_str,
1388                                           un? un->pkt->pkt.user_id->name:"[?]",
1389                                           un? un->pkt->pkt.user_id->len:3, 
1390                                           -1 );
1391
1392             log_info(rc? _("BAD signature from \"")
1393                        : sig->flags.expired ? _("Expired signature from \"")
1394                        : _("Good signature from \""));
1395             if (!opt.always_trust && un) {
1396                 fputs(_("[uncertain]"), log_stream() );
1397                 putc(' ', log_stream() );
1398             }
1399             print_utf8_string( log_stream(),
1400                                un? un->pkt->pkt.user_id->name:"[?]",
1401                                un? un->pkt->pkt.user_id->len:3 );
1402             fputs("\"\n", log_stream() );
1403         }
1404
1405         /* If we have a good signature and already printed 
1406          * the primary user ID, print all the other user IDs */
1407         if ( count && !rc ) {
1408             PKT_public_key *pk=NULL;
1409             for( un=keyblock; un; un = un->next ) {
1410                 if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1411                     pk=un->pkt->pkt.public_key;
1412                 if( un->pkt->pkttype != PKT_USER_ID )
1413                     continue;
1414                 if ( un->pkt->pkt.user_id->is_revoked )
1415                     continue;
1416                 if ( un->pkt->pkt.user_id->is_expired )
1417                     continue;
1418                 /* Only skip textual primaries */
1419                 if ( un->pkt->pkt.user_id->is_primary &&
1420                      !un->pkt->pkt.user_id->attrib_data )
1421                     continue;
1422
1423                 if(opt.show_photos && un->pkt->pkt.user_id->attrib_data)
1424                   show_photos(un->pkt->pkt.user_id->attribs,
1425                               un->pkt->pkt.user_id->numattribs,pk,NULL);
1426
1427                 log_info(    _("                aka \""));
1428                 print_utf8_string( log_stream(), un->pkt->pkt.user_id->name,
1429                                                  un->pkt->pkt.user_id->len );
1430                 fputs("\"\n", log_stream() );
1431             }
1432         }
1433         release_kbnode( keyblock );
1434
1435         if( !rc )
1436             print_notation_data( sig );
1437
1438         if( !rc && is_status_enabled() ) {
1439             /* print a status response with the fingerprint */
1440             PKT_public_key *pk = m_alloc_clear( sizeof *pk );
1441
1442             if( !get_pubkey( pk, sig->keyid ) ) {
1443                 byte array[MAX_FINGERPRINT_LEN], *p;
1444                 char buf[MAX_FINGERPRINT_LEN*2+72];
1445                 size_t i, n;
1446
1447                 fingerprint_from_pk( pk, array, &n );
1448                 p = array;
1449                 for(i=0; i < n ; i++, p++ )
1450                     sprintf(buf+2*i, "%02X", *p );
1451                 sprintf(buf+strlen(buf), " %s %lu %lu",
1452                                          strtimestamp( sig->timestamp ),
1453                                          (ulong)sig->timestamp,
1454                                          (ulong)sig->expiredate );
1455                 write_status_text( STATUS_VALIDSIG, buf );
1456             }
1457             free_public_key( pk );
1458         }
1459
1460         if( !rc )
1461             rc = check_signatures_trust( sig );
1462
1463         if(sig->flags.expired)
1464           {
1465             log_info("Signature expired %s\n",asctimestamp(sig->expiredate));
1466             rc=G10ERR_GENERAL; /* need a better error here? */
1467           }
1468         else if(sig->expiredate)
1469           log_info("Signature expires %s\n",asctimestamp(sig->expiredate));
1470
1471         if( rc )
1472             g10_errors_seen = 1;
1473         if( opt.batch && rc )
1474             g10_exit(1);
1475     }
1476     else {
1477         char buf[50];
1478         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1479                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1480                      sig->pubkey_algo, sig->digest_algo,
1481                      sig->sig_class, (ulong)sig->timestamp, rc );
1482         write_status_text( STATUS_ERRSIG, buf );
1483         if( rc == G10ERR_NO_PUBKEY ) {
1484             buf[16] = 0;
1485             write_status_text( STATUS_NO_PUBKEY, buf );
1486         }
1487         if( rc != G10ERR_NOT_PROCESSED )
1488             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1489     }
1490     return rc;
1491 }
1492
1493
1494 /****************
1495  * Process the tree which starts at node
1496  */
1497 static void
1498 proc_tree( CTX c, KBNODE node )
1499 {
1500     KBNODE n1;
1501     int rc;
1502
1503     if( opt.list_packets || opt.list_only )
1504         return;
1505
1506     /* we must skip our special plaintext marker packets here becuase
1507        they may be the root packet.  These packets are only used in
1508        addionla checks and skipping them here doesn't matter */
1509     while ( node
1510             && node->pkt->pkttype == PKT_GPG_CONTROL
1511             && node->pkt->pkt.gpg_control->control
1512                          == CTRLPKT_PLAINTEXT_MARK ) {
1513         node = node->next;
1514     }
1515     if (!node)
1516         return;
1517
1518     c->local_id = 0;
1519     c->trustletter = ' ';
1520     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1521         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1522         merge_keys_and_selfsig( node );
1523         list_node( c, node );
1524     }
1525     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1526         merge_keys_and_selfsig( node );
1527         list_node( c, node );
1528     }
1529     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1530         /* check all signatures */
1531         if( !c->have_data ) {
1532             free_md_filter_context( &c->mfx );
1533             /* prepare to create all requested message digests */
1534             c->mfx.md = md_open(0, 0);
1535
1536             /* fixme: why looking for the signature packet and not 1passpacket*/
1537             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1538                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1539             }
1540             /* ask for file and hash it */
1541             if( c->sigs_only ) {
1542                 rc = hash_datafiles( c->mfx.md, NULL,
1543                                      c->signed_data, c->sigfilename,
1544                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1545             }
1546             else {
1547                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1548                                                 iobuf_get_real_fname(c->iobuf),
1549                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1550             }
1551             if( rc ) {
1552                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1553                 return;
1554             }
1555         }
1556         else if ( c->signed_data ) {
1557             log_error (_("not a detached signature\n") );
1558             return;
1559         }
1560
1561         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1562             check_sig_and_print( c, n1 );
1563     }
1564     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1565              && node->pkt->pkt.gpg_control->control
1566                 == CTRLPKT_CLEARSIGN_START ) {
1567         /* clear text signed message */
1568         if( !c->have_data ) {
1569             log_error("cleartext signature without data\n" );
1570             return;
1571         }
1572         else if ( c->signed_data ) {
1573             log_error (_("not a detached signature\n") );
1574             return;
1575         }
1576         
1577         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1578             check_sig_and_print( c, n1 );
1579     }
1580     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1581         PKT_signature *sig = node->pkt->pkt.signature;
1582
1583         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
1584             log_info(_("standalone signature of class 0x%02x\n"),
1585                                                     sig->sig_class);
1586         else if( !c->have_data ) {
1587             /* detached signature */
1588             free_md_filter_context( &c->mfx );
1589             c->mfx.md = md_open(sig->digest_algo, 0);
1590             if( !opt.pgp2_workarounds )
1591                 ;
1592             else if( sig->digest_algo == DIGEST_ALGO_MD5
1593                      && is_RSA( sig->pubkey_algo ) ) {
1594                 /* enable a workaround for a pgp2 bug */
1595                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1596             }
1597             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1598                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1599                      && sig->sig_class == 0x01 ) {
1600                 /* enable the workaround also for pgp5 when the detached
1601                  * signature has been created in textmode */
1602                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1603             }
1604           #if 0 /* workaround disabled */
1605             /* Here we have another hack to work around a pgp 2 bug
1606              * It works by not using the textmode for detached signatures;
1607              * this will let the first signature check (on md) fail
1608              * but the second one (on md2) which adds an extra CR should
1609              * then produce the "correct" hash.  This is very, very ugly
1610              * hack but it may help in some cases (and break others)
1611              */
1612                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
1613           #endif
1614             if ( DBG_HASHING ) {
1615                 md_start_debug( c->mfx.md, "verify" );
1616                 if ( c->mfx.md2  )
1617                     md_start_debug( c->mfx.md2, "verify2" );
1618             }
1619             if( c->sigs_only ) {
1620                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
1621                                      c->signed_data, c->sigfilename,
1622                                      (sig->sig_class == 0x01) );
1623             }
1624             else {
1625                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1626                                                 iobuf_get_real_fname(c->iobuf),
1627                                                 (sig->sig_class == 0x01) );
1628             }
1629             if( rc ) {
1630                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1631                 return;
1632             }
1633         }
1634         else if ( c->signed_data ) {
1635             log_error (_("not a detached signature\n") );
1636             return;
1637         }
1638         else if ( c->pipemode.op == 'B' )
1639             ; /* this is a detached signature trough the pipemode handler */
1640         else if (!opt.quiet)
1641             log_info(_("old style (PGP 2.x) signature\n"));
1642
1643         for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
1644             check_sig_and_print( c, n1 );
1645     }
1646     else {
1647         dump_kbnode (c->list);
1648         log_error(_("invalid root packet detected in proc_tree()\n"));
1649         dump_kbnode (node);
1650     }
1651 }
1652
1653
1654
1655