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