a1daa9c04b37ea4c5184ca42c0d803d98173b068
[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               {
931                 printf(" [");
932                 printf(_("revoked: %s"),revokestr_from_pk(pk));
933                 printf("]");
934               }
935             else if( pk->expiredate )
936               {
937                 printf(" [");
938                 printf(_("expires: %s"),expirestr_from_pk(pk));
939                 printf("]");
940               }
941           }
942
943         if( !any )
944             putchar('\n');
945         if( !mainkey && opt.fingerprint > 1 )
946             print_fingerprint( pk, NULL, 0 );
947     }
948     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
949              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
950         PKT_secret_key *sk = node->pkt->pkt.secret_key;
951
952         if( opt.with_colons )
953           {
954             u32 keyid[2];
955             keyid_from_sk( sk, keyid );
956             printf("%s::%u:%d:%08lX%08lX:%s:%s:::",
957                    mainkey? "sec":"ssb",
958                    nbits_from_sk( sk ),
959                    sk->pubkey_algo,
960                    (ulong)keyid[0],(ulong)keyid[1],
961                    colon_datestr_from_sk( sk ),
962                    colon_strtime (sk->expiredate)
963                    /* fixme: add LID */ );
964           }
965         else
966           printf("%s  %4u%c/%s %s ", mainkey? "sec":"ssb",
967                  nbits_from_sk( sk ), pubkey_letter( sk->pubkey_algo ),
968                  keystr_from_sk( sk ), datestr_from_sk( sk ));
969         if( mainkey ) {
970             /* and now list all userids with their signatures */
971             for( node = node->next; node; node = node->next ) {
972                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
973                     if( !any ) {
974                         if( node->pkt->pkt.signature->sig_class == 0x20 )
975                             puts("[revoked]");
976                         else
977                             putchar('\n');
978                         any = 1;
979                     }
980                     list_node(c,  node );
981                 }
982                 else if( node->pkt->pkttype == PKT_USER_ID ) {
983                     if( any ) {
984                         if( opt.with_colons )
985                             printf("%s:::::::::",
986                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
987                         else
988                             printf( "uid%*s", 28, "" );
989                     }
990                     print_userid( node->pkt );
991                     if( opt.with_colons )
992                         putchar(':');
993                     putchar('\n');
994                     if( opt.fingerprint && !any )
995                         print_fingerprint( NULL, sk, 0 );
996                     any=1;
997                 }
998                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
999                     if( !any ) {
1000                         putchar('\n');
1001                         any = 1;
1002                     }
1003                     list_node(c,  node );
1004                 }
1005             }
1006         }
1007         if( !any )
1008             putchar('\n');
1009         if( !mainkey && opt.fingerprint > 1 )
1010             print_fingerprint( NULL, sk, 0 );
1011     }
1012     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
1013         PKT_signature *sig = node->pkt->pkt.signature;
1014         int is_selfsig = 0;
1015         int rc2=0;
1016         size_t n;
1017         char *p;
1018         int sigrc = ' ';
1019
1020         if( !opt.verbose )
1021             return;
1022
1023         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
1024             fputs("rev", stdout);
1025         else
1026             fputs("sig", stdout);
1027         if( opt.check_sigs ) {
1028             fflush(stdout);
1029             switch( (rc2=do_check_sig( c, node, &is_selfsig, NULL, NULL )) ) {
1030               case 0:                  sigrc = '!'; break;
1031               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
1032               case G10ERR_NO_PUBKEY: 
1033               case G10ERR_UNU_PUBKEY:  sigrc = '?'; break;
1034               default:                 sigrc = '%'; break;
1035             }
1036         }
1037         else {  /* check whether this is a self signature */
1038             u32 keyid[2];
1039
1040             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
1041                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
1042                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
1043                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
1044                 else
1045                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
1046
1047                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
1048                     is_selfsig = 1;
1049             }
1050         }
1051         if( opt.with_colons ) {
1052             putchar(':');
1053             if( sigrc != ' ' )
1054                 putchar(sigrc);
1055             printf("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1056                    (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1057                    colon_datestr_from_sig(sig),
1058                    colon_expirestr_from_sig(sig));
1059
1060             if(sig->trust_depth || sig->trust_value)
1061               printf("%d %d",sig->trust_depth,sig->trust_value);
1062             printf(":");
1063
1064             if(sig->trust_regexp)
1065               print_string(stdout,sig->trust_regexp,
1066                            strlen(sig->trust_regexp),':');
1067             printf(":");
1068         }
1069         else
1070           printf("%c       %s %s   ",
1071                  sigrc, keystr(sig->keyid), datestr_from_sig(sig));
1072         if( sigrc == '%' )
1073             printf("[%s] ", g10_errstr(rc2) );
1074         else if( sigrc == '?' )
1075             ;
1076         else if( is_selfsig ) {
1077             if( opt.with_colons )
1078                 putchar(':');
1079             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
1080             if( opt.with_colons )
1081                 putchar(':');
1082         }
1083         else if( !opt.fast_list_mode ) {
1084             p = get_user_id( sig->keyid, &n );
1085             print_string( stdout, p, n, opt.with_colons );
1086             m_free(p);
1087         }
1088         if( opt.with_colons )
1089             printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1090         putchar('\n');
1091     }
1092     else
1093         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
1094 }
1095
1096
1097
1098 int
1099 proc_packets( void *anchor, IOBUF a )
1100 {
1101     int rc;
1102     CTX c = m_alloc_clear( sizeof *c );
1103
1104     c->anchor = anchor;
1105     rc = do_proc_packets( c, a );
1106     m_free( c );
1107     return rc;
1108 }
1109
1110
1111
1112 int
1113 proc_signature_packets( void *anchor, IOBUF a,
1114                         STRLIST signedfiles, const char *sigfilename )
1115 {
1116     CTX c = m_alloc_clear( sizeof *c );
1117     int rc;
1118
1119     c->anchor = anchor;
1120     c->sigs_only = 1;
1121     c->signed_data = signedfiles;
1122     c->sigfilename = sigfilename;
1123     rc = do_proc_packets( c, a );
1124     m_free( c );
1125     return rc;
1126 }
1127
1128 int
1129 proc_encryption_packets( void *anchor, IOBUF a )
1130 {
1131     CTX c = m_alloc_clear( sizeof *c );
1132     int rc;
1133
1134     c->anchor = anchor;
1135     c->encrypt_only = 1;
1136     rc = do_proc_packets( c, a );
1137     m_free( c );
1138     return rc;
1139 }
1140
1141
1142 int
1143 do_proc_packets( CTX c, IOBUF a )
1144 {
1145     PACKET *pkt = m_alloc( sizeof *pkt );
1146     int rc=0;
1147     int any_data=0;
1148     int newpkt;
1149
1150     c->iobuf = a;
1151     init_packet(pkt);
1152     while( (rc=parse_packet(a, pkt)) != -1 ) {
1153         any_data = 1;
1154         if( rc ) {
1155             free_packet(pkt);
1156             /* stop processing when an invalid packet has been encountered
1157              * but don't do so when we are doing a --list-packet. */
1158             if( rc == G10ERR_INVALID_PACKET && opt.list_packets != 2 )
1159                 break;
1160             continue;
1161         }
1162         newpkt = -1;
1163         if( opt.list_packets ) {
1164             switch( pkt->pkttype ) {
1165               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1166               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1167               case PKT_ENCRYPTED:
1168               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1169               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1170               default: newpkt = 0; break;
1171             }
1172         }
1173         else if( c->sigs_only ) {
1174             switch( pkt->pkttype ) {
1175               case PKT_PUBLIC_KEY:
1176               case PKT_SECRET_KEY:
1177               case PKT_USER_ID:
1178               case PKT_SYMKEY_ENC:
1179               case PKT_PUBKEY_ENC:
1180               case PKT_ENCRYPTED:
1181               case PKT_ENCRYPTED_MDC:
1182                 write_status_text( STATUS_UNEXPECTED, "0" );
1183                 rc = G10ERR_UNEXPECTED;
1184                 goto leave;
1185               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1186               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1187               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1188               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1189               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1190               default: newpkt = 0; break;
1191             }
1192         }
1193         else if( c->encrypt_only ) {
1194             switch( pkt->pkttype ) {
1195               case PKT_PUBLIC_KEY:
1196               case PKT_SECRET_KEY:
1197               case PKT_USER_ID:
1198                 write_status_text( STATUS_UNEXPECTED, "0" );
1199                 rc = G10ERR_UNEXPECTED;
1200                 goto leave;
1201               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1202               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1203               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1204               case PKT_ENCRYPTED:
1205               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1206               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1207               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1208               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1209               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1210               default: newpkt = 0; break;
1211             }
1212         }
1213         else {
1214             switch( pkt->pkttype ) {
1215               case PKT_PUBLIC_KEY:
1216               case PKT_SECRET_KEY:
1217                 release_list( c );
1218                 c->list = new_kbnode( pkt );
1219                 newpkt = 1;
1220                 break;
1221               case PKT_PUBLIC_SUBKEY:
1222               case PKT_SECRET_SUBKEY:
1223                 newpkt = add_subkey( c, pkt );
1224                 break;
1225               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1226               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1227               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1228               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1229               case PKT_ENCRYPTED:
1230               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1231               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1232               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1233               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1234               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1235               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1236               default: newpkt = 0; break;
1237             }
1238         }
1239         /* This is a very ugly construct and frankly, I don't remember why
1240          * I used it.  Adding the MDC check here is a hack.
1241          * The right solution is to initiate another context for encrypted
1242          * packet and not to reuse the current one ...  It works right
1243          * when there is a compression packet inbetween which adds just
1244          * an extra layer.
1245          * Hmmm: Rewrite this whole module here?? 
1246          */
1247         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1248             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
1249
1250         if( newpkt == -1 )
1251             ;
1252         else if( newpkt ) {
1253             pkt = m_alloc( sizeof *pkt );
1254             init_packet(pkt);
1255         }
1256         else
1257             free_packet(pkt);
1258         if ( c->pipemode.stop_now ) {
1259             /* we won't get an EOF in pipemode, so we have to 
1260              * break the loop here */ 
1261             rc = -1;
1262             break;
1263         }
1264     }
1265     if( rc == G10ERR_INVALID_PACKET )
1266         write_status_text( STATUS_NODATA, "3" );
1267     if( any_data )
1268         rc = 0;
1269     else if( rc == -1 )
1270         write_status_text( STATUS_NODATA, "2" );
1271
1272
1273   leave:
1274     release_list( c );
1275     m_free(c->dek);
1276     free_packet( pkt );
1277     m_free( pkt );
1278     free_md_filter_context( &c->mfx );
1279     return rc;
1280 }
1281
1282
1283 static int
1284 check_sig_and_print( CTX c, KBNODE node )
1285 {
1286     PKT_signature *sig = node->pkt->pkt.signature;
1287     const char *astr;
1288     int rc, is_expkey=0, is_revkey=0;
1289
1290     if( opt.skip_verify ) {
1291         log_info(_("signature verification suppressed\n"));
1292         return 0;
1293     }
1294
1295     /* It is not in all cases possible to check multiple signatures:
1296      * PGP 2 (which is also allowed by OpenPGP), does use the packet
1297      * sequence: sig+data,  OpenPGP does use onepas+data=sig and GnuPG
1298      * sometimes uses (because I did'nt read the specs right) data+sig.
1299      * Because it is possible to create multiple signatures with
1300      * different packet sequence (e.g. data+sig and sig+data) it might
1301      * not be possible to get it right:  let's say we have:
1302      * data+sig, sig+data,sig+data and we have not yet encountered the last
1303      * data, we could also see this a one data with 2 signatures and then 
1304      * data+sig.
1305      * To protect against this we check that all signatures follow
1306      * without any intermediate packets.  Note, that we won't get this
1307      * error when we use onepass packets or cleartext signatures because
1308      * we reset the list every time
1309      *
1310      * FIXME: Now that we have these marker packets, we should create a 
1311      * real grammar and check against this.
1312      */
1313     {
1314         KBNODE n;
1315         int n_sig=0;
1316
1317         for (n=c->list; n; n=n->next ) {
1318             if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1319                 n_sig++;
1320         }
1321         if (n_sig > 1) { /* more than one signature - check sequence */
1322             int tmp, onepass;
1323
1324             for (tmp=onepass=0,n=c->list; n; n=n->next ) {
1325                 if (n->pkt->pkttype == PKT_ONEPASS_SIG) 
1326                     onepass++;
1327                 else if (n->pkt->pkttype == PKT_GPG_CONTROL
1328                          && n->pkt->pkt.gpg_control->control
1329                             == CTRLPKT_CLEARSIGN_START ) {
1330                     onepass++; /* handle the same way as a onepass */
1331                 }
1332                 else if ( (tmp && n->pkt->pkttype != PKT_SIGNATURE) ) {
1333                     log_error(_("can't handle these multiple signatures\n"));
1334                     return 0;
1335                 }
1336                 else if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1337                     tmp = 1;
1338                 else if (!tmp && !onepass 
1339                          && n->pkt->pkttype == PKT_GPG_CONTROL
1340                          && n->pkt->pkt.gpg_control->control
1341                             == CTRLPKT_PLAINTEXT_MARK ) {
1342                     /* plaintext before signatures but no one-pass packets*/
1343                     log_error(_("can't handle these multiple signatures\n"));
1344                     return 0;
1345                 }
1346             }
1347         }
1348     }
1349
1350     astr = pubkey_algo_to_string( sig->pubkey_algo );
1351     if(keystrlen()>8)
1352       {
1353         log_info(_("Signature made %s\n"),asctimestamp(sig->timestamp));
1354         log_info(_("               using %s key %s\n"),
1355                  astr? astr: "?",keystr(sig->keyid));
1356       }
1357     else
1358       log_info(_("Signature made %s using %s key ID %s\n"),
1359                asctimestamp(sig->timestamp), astr? astr: "?",
1360                keystr(sig->keyid));
1361
1362     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1363
1364     /* If the key isn't found, check for a preferred keyserver */
1365
1366     if(rc==G10ERR_NO_PUBKEY && sig->flags.pref_ks)
1367       {
1368         const byte *p;
1369         int seq=0;
1370         size_t n;
1371
1372         while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1373           {
1374             /* According to my favorite copy editor, in English
1375                grammar, you say "at" if the key is located on a web
1376                page, but "from" if it is located on a keyserver.  I'm
1377                not going to even try to make two strings here :) */
1378             log_info(_("Key available at: ") );
1379             print_utf8_string( log_stream(), p, n );
1380             putc( '\n', log_stream() );
1381
1382             if(opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1383                && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1384               {
1385                 struct keyserver_spec *spec;
1386
1387                 spec=parse_preferred_keyserver(sig);
1388                 if(spec)
1389                   {
1390                     int res;
1391
1392                     glo_ctrl.in_auto_key_retrieve++;
1393                     res=keyserver_import_keyid(sig->keyid,spec);
1394                     glo_ctrl.in_auto_key_retrieve--;
1395                     if(!res)
1396                       rc=do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1397                     free_keyserver_spec(spec);
1398
1399                     if(!rc)
1400                       break;
1401                   }
1402               }
1403           }
1404       }
1405
1406     /* If the preferred keyserver thing above didn't work, this is a
1407        second try. */
1408
1409     if( rc == G10ERR_NO_PUBKEY && opt.keyserver
1410         && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE))
1411       {
1412         int res;
1413
1414         glo_ctrl.in_auto_key_retrieve++;
1415         res=keyserver_import_keyid ( sig->keyid, opt.keyserver );
1416         glo_ctrl.in_auto_key_retrieve--;
1417         if(!res)
1418           rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1419       }
1420
1421     if( !rc || rc == G10ERR_BAD_SIGN ) {
1422         KBNODE un, keyblock;
1423         int count=0, statno;
1424         char keyid_str[50];
1425         PKT_public_key *pk=NULL;
1426
1427         if(rc)
1428           statno=STATUS_BADSIG;
1429         else if(sig->flags.expired)
1430           statno=STATUS_EXPSIG;
1431         else if(is_expkey)
1432           statno=STATUS_EXPKEYSIG;
1433         else if(is_revkey)
1434           statno=STATUS_REVKEYSIG;
1435         else
1436           statno=STATUS_GOODSIG;
1437
1438         keyblock = get_pubkeyblock( sig->keyid );
1439
1440         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1441                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1442
1443         /* find and print the primary user ID */
1444         for( un=keyblock; un; un = un->next ) {
1445             char *p;
1446             int valid;
1447             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1448               {
1449                 pk=un->pkt->pkt.public_key;
1450                 continue;
1451               }
1452             if( un->pkt->pkttype != PKT_USER_ID )
1453                 continue;
1454             if ( !un->pkt->pkt.user_id->created )
1455                 continue;
1456             if ( un->pkt->pkt.user_id->is_revoked )
1457                 continue;
1458             if ( un->pkt->pkt.user_id->is_expired )
1459                 continue;
1460             if ( !un->pkt->pkt.user_id->is_primary )
1461                 continue;
1462             /* We want the textual primary user ID here */
1463             if ( un->pkt->pkt.user_id->attrib_data )
1464                 continue;
1465
1466             assert(pk);
1467
1468             /* Get it before we print anything to avoid interrupting
1469                the output with the "please do a --check-trustdb"
1470                line. */
1471             valid=get_validity(pk,un->pkt->pkt.user_id);
1472
1473             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1474             write_status_text_and_buffer (statno, keyid_str,
1475                                           un->pkt->pkt.user_id->name,
1476                                           un->pkt->pkt.user_id->len, 
1477                                           -1 );
1478
1479             p=utf8_to_native(un->pkt->pkt.user_id->name,
1480                              un->pkt->pkt.user_id->len,0);
1481
1482             if(rc)
1483               log_info(_("BAD signature from \"%s\""),p);
1484             else if(sig->flags.expired)
1485               log_info(_("Expired signature from \"%s\""),p);
1486             else
1487               log_info(_("Good signature from \"%s\""),p);
1488
1489             m_free(p);
1490
1491             if(opt.verify_options&VERIFY_SHOW_VALIDITY)
1492               fprintf(log_stream()," [%s]\n",trust_value_to_string(valid));
1493             else
1494               fputs("\n", log_stream() );
1495             count++;
1496         }
1497         if( !count ) {  /* just in case that we have no valid textual
1498                            userid */
1499             char *p;
1500
1501             /* Try for an invalid textual userid */
1502             for( un=keyblock; un; un = un->next ) {
1503                 if( un->pkt->pkttype == PKT_USER_ID &&
1504                     !un->pkt->pkt.user_id->attrib_data )
1505                     break;
1506             }
1507
1508             /* Try for any userid at all */
1509             if(!un) {
1510                 for( un=keyblock; un; un = un->next ) {
1511                     if( un->pkt->pkttype == PKT_USER_ID )
1512                         break;
1513                 }
1514             }
1515
1516             if (opt.trust_model==TM_ALWAYS || !un)
1517                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1518
1519             write_status_text_and_buffer (statno, keyid_str,
1520                                           un? un->pkt->pkt.user_id->name:"[?]",
1521                                           un? un->pkt->pkt.user_id->len:3, 
1522                                           -1 );
1523
1524             if(un)
1525               p=utf8_to_native(un->pkt->pkt.user_id->name,
1526                                un->pkt->pkt.user_id->len,0);
1527             else
1528               p=m_strdup("[?]");
1529
1530             if(rc)
1531               log_info(_("BAD signature from \"%s\""),p);
1532             else if(sig->flags.expired)
1533               log_info(_("Expired signature from \"%s\""),p);
1534             else
1535               log_info(_("Good signature from \"%s\""),p);
1536             if (opt.trust_model!=TM_ALWAYS && un)
1537               {
1538                 putc(' ', log_stream() );
1539                 fputs(_("[uncertain]"), log_stream() );
1540               }
1541             fputs("\n", log_stream() );
1542         }
1543
1544         /* If we have a good signature and already printed 
1545          * the primary user ID, print all the other user IDs */
1546         if ( count && !rc ) {
1547             char *p;
1548             for( un=keyblock; un; un = un->next ) {
1549                 if( un->pkt->pkttype != PKT_USER_ID )
1550                     continue;
1551                 if((un->pkt->pkt.user_id->is_revoked
1552                     || un->pkt->pkt.user_id->is_expired)
1553                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1554                   continue;
1555                 /* Only skip textual primaries */
1556                 if ( un->pkt->pkt.user_id->is_primary &&
1557                      !un->pkt->pkt.user_id->attrib_data )
1558                     continue;
1559
1560                 if(un->pkt->pkt.user_id->attrib_data)
1561                   {
1562                     dump_attribs(un->pkt->pkt.user_id,pk,NULL);
1563
1564                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1565                       show_photos(un->pkt->pkt.user_id->attribs,
1566                                   un->pkt->pkt.user_id->numattribs,pk,NULL);
1567                   }
1568
1569                 p=utf8_to_native(un->pkt->pkt.user_id->name,
1570                                  un->pkt->pkt.user_id->len,0);
1571                 log_info(_("                aka \"%s\""),p);
1572                 m_free(p);
1573
1574                 if(opt.verify_options&VERIFY_SHOW_VALIDITY)
1575                   {
1576                     const char *valid;
1577                     if(un->pkt->pkt.user_id->is_revoked)
1578                       valid=_("revoked");
1579                     else if(un->pkt->pkt.user_id->is_expired)
1580                       valid=_("expired");
1581                     else
1582                       valid=trust_value_to_string(get_validity(pk,
1583                                                                un->pkt->
1584                                                                pkt.user_id));
1585                     fprintf(log_stream()," [%s]\n",valid);
1586                   }
1587                 else
1588                   fputs("\n", log_stream() );
1589             }
1590         }
1591         release_kbnode( keyblock );
1592
1593         if( !rc )
1594           {
1595             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1596               show_policy_url(sig,0,1);
1597             else
1598               show_policy_url(sig,0,2);
1599
1600             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1601               show_keyserver_url(sig,0,1);
1602             else
1603               show_keyserver_url(sig,0,2);
1604
1605             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1606               show_notation(sig,0,1,
1607                         ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
1608                         ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
1609             else
1610               show_notation(sig,0,2,0);
1611           }
1612
1613         if( !rc && is_status_enabled() ) {
1614             /* print a status response with the fingerprint */
1615             PKT_public_key *vpk = m_alloc_clear( sizeof *vpk );
1616
1617             if( !get_pubkey( vpk, sig->keyid ) ) {
1618                 byte array[MAX_FINGERPRINT_LEN], *p;
1619                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1620                 size_t i, n;
1621
1622                 bufp = buf;
1623                 fingerprint_from_pk( vpk, array, &n );
1624                 p = array;
1625                 for(i=0; i < n ; i++, p++, bufp += 2)
1626                     sprintf(bufp, "%02X", *p );
1627                 /* TODO: Replace the reserved '0' in the field below
1628                    with bits for status flags (policy url, notation,
1629                    etc.).  Remember to make the buffer larger to
1630                    match! */
1631                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1632                         strtimestamp( sig->timestamp ),
1633                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1634                         sig->version,sig->pubkey_algo,sig->digest_algo,
1635                         sig->sig_class);
1636                 bufp = bufp + strlen (bufp);
1637                 if (!vpk->is_primary) {
1638                    u32 akid[2];
1639  
1640                    akid[0] = vpk->main_keyid[0];
1641                    akid[1] = vpk->main_keyid[1];
1642                    free_public_key (vpk);
1643                    vpk = m_alloc_clear( sizeof *vpk );
1644                    if (get_pubkey (vpk, akid)) {
1645                      /* impossible error, we simply return a zeroed out fpr */
1646                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1647                      memset (array, 0, n);
1648                    }
1649                    else
1650                      fingerprint_from_pk( vpk, array, &n );
1651                 }
1652                 p = array;
1653                 for(i=0; i < n ; i++, p++, bufp += 2)
1654                     sprintf(bufp, "%02X", *p );
1655                 write_status_text( STATUS_VALIDSIG, buf );
1656             }
1657             free_public_key( vpk );
1658         }
1659
1660         if( !rc )
1661             rc = check_signatures_trust( sig );
1662
1663         if(sig->flags.expired)
1664           {
1665             log_info(_("Signature expired %s\n"),
1666                      asctimestamp(sig->expiredate));
1667             rc=G10ERR_GENERAL; /* need a better error here? */
1668           }
1669         else if(sig->expiredate)
1670           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1671
1672         if(opt.verbose)
1673           log_info(_("%s signature, digest algorithm %s\n"),
1674                    sig->sig_class==0x00?_("binary"):
1675                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1676                    digest_algo_to_string(sig->digest_algo));
1677
1678         if( rc )
1679             g10_errors_seen = 1;
1680         if( opt.batch && rc )
1681             g10_exit(1);
1682     }
1683     else {
1684         char buf[50];
1685         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1686                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1687                      sig->pubkey_algo, sig->digest_algo,
1688                      sig->sig_class, (ulong)sig->timestamp, rc );
1689         write_status_text( STATUS_ERRSIG, buf );
1690         if( rc == G10ERR_NO_PUBKEY ) {
1691             buf[16] = 0;
1692             write_status_text( STATUS_NO_PUBKEY, buf );
1693         }
1694         if( rc != G10ERR_NOT_PROCESSED )
1695             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1696     }
1697     return rc;
1698 }
1699
1700
1701 /****************
1702  * Process the tree which starts at node
1703  */
1704 static void
1705 proc_tree( CTX c, KBNODE node )
1706 {
1707     KBNODE n1;
1708     int rc;
1709
1710     if( opt.list_packets || opt.list_only )
1711         return;
1712
1713     /* we must skip our special plaintext marker packets here becuase
1714        they may be the root packet.  These packets are only used in
1715        addionla checks and skipping them here doesn't matter */
1716     while ( node
1717             && node->pkt->pkttype == PKT_GPG_CONTROL
1718             && node->pkt->pkt.gpg_control->control
1719                          == CTRLPKT_PLAINTEXT_MARK ) {
1720         node = node->next;
1721     }
1722     if (!node)
1723         return;
1724
1725     c->trustletter = ' ';
1726     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1727         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1728         merge_keys_and_selfsig( node );
1729         list_node( c, node );
1730     }
1731     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1732         merge_keys_and_selfsig( node );
1733         list_node( c, node );
1734     }
1735     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1736         /* check all signatures */
1737         if( !c->have_data ) {
1738             free_md_filter_context( &c->mfx );
1739             /* prepare to create all requested message digests */
1740             c->mfx.md = md_open(0, 0);
1741
1742             /* fixme: why looking for the signature packet and not 1passpacket*/
1743             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1744                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1745             }
1746             /* ask for file and hash it */
1747             if( c->sigs_only ) {
1748                 rc = hash_datafiles( c->mfx.md, NULL,
1749                                      c->signed_data, c->sigfilename,
1750                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1751             }
1752             else {
1753                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1754                                                 iobuf_get_real_fname(c->iobuf),
1755                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1756             }
1757             if( rc ) {
1758                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1759                 return;
1760             }
1761         }
1762         else if ( c->signed_data ) {
1763             log_error (_("not a detached signature\n") );
1764             return;
1765         }
1766
1767         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1768             check_sig_and_print( c, n1 );
1769     }
1770     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1771              && node->pkt->pkt.gpg_control->control
1772                 == CTRLPKT_CLEARSIGN_START ) {
1773         /* clear text signed message */
1774         if( !c->have_data ) {
1775             log_error("cleartext signature without data\n" );
1776             return;
1777         }
1778         else if ( c->signed_data ) {
1779             log_error (_("not a detached signature\n") );
1780             return;
1781         }
1782         
1783         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1784             check_sig_and_print( c, n1 );
1785     }
1786     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1787         PKT_signature *sig = node->pkt->pkt.signature;
1788         int multiple_ok=1;
1789
1790         n1=find_next_kbnode(node, PKT_SIGNATURE);
1791         if(n1)
1792           {
1793             byte class=sig->sig_class;
1794             byte hash=sig->digest_algo;
1795
1796             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1797               {
1798                 /* We can't currently handle multiple signatures of
1799                    different classes or digests (we'd pretty much have
1800                    to run a different hash context for each), but if
1801                    they are all the same, make an exception. */
1802                 if(n1->pkt->pkt.signature->sig_class!=class
1803                    || n1->pkt->pkt.signature->digest_algo!=hash)
1804                   {
1805                     multiple_ok=0;
1806                     log_info(_("WARNING: multiple signatures detected.  "
1807                                "Only the first will be checked.\n"));
1808                     break;
1809                   }
1810               }
1811           }
1812
1813         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
1814             log_info(_("standalone signature of class 0x%02x\n"),
1815                                                     sig->sig_class);
1816         else if( !c->have_data ) {
1817             /* detached signature */
1818             free_md_filter_context( &c->mfx );
1819             c->mfx.md = md_open(sig->digest_algo, 0);
1820             if( !opt.pgp2_workarounds )
1821                 ;
1822             else if( sig->digest_algo == DIGEST_ALGO_MD5
1823                      && is_RSA( sig->pubkey_algo ) ) {
1824                 /* enable a workaround for a pgp2 bug */
1825                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1826             }
1827             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1828                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1829                      && sig->sig_class == 0x01 ) {
1830                 /* enable the workaround also for pgp5 when the detached
1831                  * signature has been created in textmode */
1832                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1833             }
1834 #if 0 /* workaround disabled */
1835             /* Here we have another hack to work around a pgp 2 bug
1836              * It works by not using the textmode for detached signatures;
1837              * this will let the first signature check (on md) fail
1838              * but the second one (on md2) which adds an extra CR should
1839              * then produce the "correct" hash.  This is very, very ugly
1840              * hack but it may help in some cases (and break others)
1841              */
1842                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
1843 #endif
1844             if ( DBG_HASHING ) {
1845                 md_start_debug( c->mfx.md, "verify" );
1846                 if ( c->mfx.md2  )
1847                     md_start_debug( c->mfx.md2, "verify2" );
1848             }
1849             if( c->sigs_only ) {
1850                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
1851                                      c->signed_data, c->sigfilename,
1852                                      (sig->sig_class == 0x01) );
1853             }
1854             else {
1855                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1856                                                 iobuf_get_real_fname(c->iobuf),
1857                                                 (sig->sig_class == 0x01) );
1858             }
1859             if( rc ) {
1860                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1861                 return;
1862             }
1863         }
1864         else if ( c->signed_data ) {
1865             log_error (_("not a detached signature\n") );
1866             return;
1867         }
1868         else if ( c->pipemode.op == 'B' )
1869             ; /* this is a detached signature trough the pipemode handler */
1870         else if (!opt.quiet)
1871             log_info(_("old style (PGP 2.x) signature\n"));
1872
1873         if(multiple_ok)
1874           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
1875             check_sig_and_print( c, n1 );
1876         else
1877           check_sig_and_print( c, node );
1878     }
1879     else {
1880         dump_kbnode (c->list);
1881         log_error(_("invalid root packet detected in proc_tree()\n"));
1882         dump_kbnode (node);
1883     }
1884 }