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