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