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