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