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