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