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