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