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