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