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