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