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