See ChangeLog: Fri Sep 3 10:06:06 CEST 1999 Werner Koch
[gnupg.git] / g10 / mainproc.c
1 /* maPPPPinproc.c - handle packets
2  *      Copyright (C) 1998, 1999 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 "hkp.h"
41
42
43 struct kidlist_item {
44     struct kidlist_item *next;
45     u32 kid[2];
46     int pubkey_algo;
47     int reason;
48 };
49
50
51
52 /****************
53  * Structure to hold the context
54  */
55 typedef struct mainproc_context *CTX;
56 struct mainproc_context {
57     struct mainproc_context *anchor;  /* may be useful in the future */
58     PKT_public_key *last_pubkey;
59     PKT_secret_key *last_seckey;
60     PKT_user_id     *last_user_id;
61     md_filter_context_t mfx;
62     int sigs_only;   /* process only signatures and reject all other stuff */
63     int encrypt_only; /* process only encrytion messages */
64     STRLIST signed_data;
65     const char *sigfilename;
66     DEK *dek;
67     int last_was_session_key;
68     KBNODE list;   /* the current list of packets */
69     int have_data;
70     IOBUF iobuf;    /* used to get the filename etc. */
71     int trustletter; /* temp usage in list_node */
72     ulong local_id;    /* ditto */
73     struct kidlist_item *failed_pkenc;  /* list of packets for which
74                                            we do not have a secret key */
75 };
76
77
78 static int do_proc_packets( CTX c, IOBUF a );
79
80 static void list_node( CTX c, KBNODE node );
81 static void proc_tree( CTX c, KBNODE node );
82
83
84 static void
85 release_list( CTX c )
86 {
87     if( !c->list )
88         return;
89     proc_tree(c, c->list );
90     release_kbnode( c->list );
91     while( c->failed_pkenc ) {
92         struct kidlist_item *tmp = c->failed_pkenc->next;
93         m_free( c->failed_pkenc );
94         c->failed_pkenc = tmp;
95     }
96     c->failed_pkenc = NULL;
97     c->list = NULL;
98 }
99
100
101 static int
102 add_onepass_sig( CTX c, PACKET *pkt )
103 {
104     KBNODE node;
105
106     if( c->list ) { /* add another packet */
107         if( c->list->pkt->pkttype != PKT_ONEPASS_SIG ) {
108            log_error("add_onepass_sig: another packet is in the way\n");
109            release_list( c );
110            c->list = new_kbnode( pkt );
111         }
112         else
113            add_kbnode( c->list, new_kbnode( pkt ));
114     }
115     else /* insert the first one */
116         c->list = node = new_kbnode( pkt );
117
118     return 1;
119 }
120
121
122
123 static int
124 add_user_id( CTX c, PACKET *pkt )
125 {
126     if( !c->list ) {
127         log_error("orphaned user ID\n" );
128         return 0;
129     }
130     add_kbnode( c->list, new_kbnode( pkt ) );
131     return 1;
132 }
133
134 static int
135 add_subkey( CTX c, PACKET *pkt )
136 {
137     if( !c->list ) {
138         log_error("subkey w/o mainkey\n" );
139         return 0;
140     }
141     add_kbnode( c->list, new_kbnode( pkt ) );
142     return 1;
143 }
144
145 static int
146 add_ring_trust( CTX c, PACKET *pkt )
147 {
148     if( !c->list ) {
149         log_error("ring trust w/o key\n" );
150         return 0;
151     }
152     add_kbnode( c->list, new_kbnode( pkt ) );
153     return 1;
154 }
155
156
157 static int
158 add_signature( CTX c, PACKET *pkt )
159 {
160     KBNODE node;
161
162     if( pkt->pkttype == PKT_SIGNATURE && !c->list ) {
163         /* This is the first signature for the following datafile.
164          * G10 does not write such packets; instead it always uses
165          * onepass-sig packets.  The drawback of PGP's method
166          * of prepending the signature to the data is
167          * that it is not possible to make a signature from data read
168          * from stdin.  (G10 is able to read PGP stuff anyway.) */
169         node = new_kbnode( pkt );
170         c->list = node;
171         return 1;
172     }
173     else if( !c->list )
174         return 0; /* oops (invalid packet sequence)*/
175     else if( !c->list->pkt )
176         BUG();  /* so nicht */
177
178     /* add a new signature node id at the end */
179     node = new_kbnode( pkt );
180     add_kbnode( c->list, node );
181     return 1;
182 }
183
184
185 static void
186 proc_symkey_enc( CTX c, PACKET *pkt )
187 {
188     PKT_symkey_enc *enc;
189
190     enc = pkt->pkt.symkey_enc;
191     if( enc->seskeylen )
192         log_error( "symkey_enc packet with session keys are not supported!\n");
193     else {
194         c->last_was_session_key = 2;
195         c->dek = passphrase_to_dek( NULL, 0, enc->cipher_algo, &enc->s2k, 0 );
196     }
197     free_packet(pkt);
198 }
199
200 static void
201 proc_pubkey_enc( CTX c, PACKET *pkt )
202 {
203     PKT_pubkey_enc *enc;
204     int result = 0;
205
206     /* check whether the secret key is available and store in this case */
207     c->last_was_session_key = 1;
208     enc = pkt->pkt.pubkey_enc;
209     /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
210     /* Hmmm: why do I have this algo check here - anyway there is
211      * function to check it. */
212     if( opt.verbose )
213         log_info(_("public key is %08lX\n"), (ulong)enc->keyid[1] );
214
215     if( is_status_enabled() ) {
216         char buf[50];
217         sprintf(buf, "%08lX%08lX %d 0",
218                 (ulong)enc->keyid[0], (ulong)enc->keyid[1], enc->pubkey_algo );
219         write_status_text( STATUS_ENC_TO, buf );
220     }
221
222
223     if( is_ELGAMAL(enc->pubkey_algo)
224         || enc->pubkey_algo == PUBKEY_ALGO_DSA
225         || is_RSA(enc->pubkey_algo)  ) {
226         if ( !c->dek && ((!enc->keyid[0] && !enc->keyid[1])
227                           || !seckey_available( enc->keyid )) ) {
228             c->dek = m_alloc_secure( sizeof *c->dek );
229             if( (result = get_session_key( enc, c->dek )) ) {
230                 /* error: delete the DEK */
231                 m_free(c->dek); c->dek = NULL;
232             }
233         }
234         else
235             result = G10ERR_NO_SECKEY;
236     }
237     else
238         result = G10ERR_PUBKEY_ALGO;
239
240     if( result == -1 )
241         ;
242     else if( !result ) {
243         if( opt.verbose > 1 )
244             log_info( _("public key encrypted data: good DEK\n") );
245     }
246     else { /* store it for later display */
247         struct kidlist_item *x = m_alloc( sizeof *x );
248         x->kid[0] = enc->keyid[0];
249         x->kid[1] = enc->keyid[1];
250         x->pubkey_algo = enc->pubkey_algo;
251         x->reason = result;
252         x->next = c->failed_pkenc;
253         c->failed_pkenc = x;
254     }
255     free_packet(pkt);
256 }
257
258
259
260 /****************
261  * Print the list of public key encrypted packets which we could
262  * not decrypt.
263  */
264 static void
265 print_failed_pkenc( struct kidlist_item *list )
266 {
267     for( ; list; list = list->next ) {
268         PKT_public_key *pk = m_alloc_clear( sizeof *pk );
269         const char *algstr = pubkey_algo_to_string( list->pubkey_algo );
270
271         pk->pubkey_algo = list->pubkey_algo;
272         if( !get_pubkey( pk, list->kid ) ) {
273             size_t n;
274             char *p;
275             log_info( _("encrypted with %u-bit %s key, ID %08lX, created %s\n"),
276                        nbits_from_pk( pk ), algstr, (ulong)list->kid[1],
277                        strtimestamp(pk->timestamp) );
278             fputs("      \"", log_stream() );
279             p = get_user_id( list->kid, &n );
280             print_string( log_stream(), p, n, '"' );
281             m_free(p);
282             fputs("\"\n", log_stream() );
283         }
284         else {
285             log_info(_("encrypted with %s key, ID %08lX\n"),
286                         algstr, (ulong) list->kid[1] );
287         }
288         free_public_key( pk );
289
290         if( list->reason == G10ERR_NO_SECKEY ) {
291             log_info(_("no secret key for decryption available\n"));
292             if( is_status_enabled() ) {
293                 char buf[20];
294                 sprintf(buf,"%08lX%08lX", (ulong)list->kid[0],
295                                           (ulong)list->kid[1] );
296                 write_status_text( STATUS_NO_SECKEY, buf );
297             }
298         }
299         else
300             log_error(_("public key decryption failed: %s\n"),
301                                                 g10_errstr(list->reason));
302     }
303 }
304
305
306 static void
307 proc_encrypted( CTX c, PACKET *pkt )
308 {
309     int result = 0;
310
311     print_failed_pkenc( c->failed_pkenc );
312
313     /*log_debug("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
314     if( !c->dek && !c->last_was_session_key ) {
315         /* assume this is old conventional encrypted data */
316         c->dek = passphrase_to_dek( NULL, 0,
317                     opt.def_cipher_algo ? opt.def_cipher_algo
318                                         : DEFAULT_CIPHER_ALGO, NULL, 0 );
319     }
320     else if( !c->dek )
321         result = G10ERR_NO_SECKEY;
322     if( !result )
323         result = decrypt_data( c, pkt->pkt.encrypted, c->dek );
324     m_free(c->dek); c->dek = NULL;
325     if( result == -1 )
326         ;
327     else if( !result ) {
328         write_status( STATUS_DECRYPTION_OKAY );
329         if( opt.verbose > 1 )
330             log_info(_("decryption okay\n"));
331         if( pkt->pkt.encrypted->mdc_method )
332             write_status( STATUS_GOODMDC );
333     }
334     else if( result == G10ERR_BAD_SIGN ) {
335         log_error(_("WARNING: encrypted message has been manipulated!\n"));
336         write_status( STATUS_BADMDC );
337     }
338     else {
339         write_status( STATUS_DECRYPTION_FAILED );
340         log_error(_("decryption failed: %s\n"), g10_errstr(result));
341         /* Hmmm: does this work when we have encrypted using a multiple
342          * ways to specify the session key (symmmetric and PK)*/
343     }
344     free_packet(pkt);
345     c->last_was_session_key = 0;
346 }
347
348
349
350 static void
351 proc_plaintext( CTX c, PACKET *pkt )
352 {
353     PKT_plaintext *pt = pkt->pkt.plaintext;
354     int any, clearsig, only_md5, rc;
355     KBNODE n;
356
357     if( pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8 ) )
358         log_info(_("NOTE: sender requested \"for-your-eyes-only\"\n"));
359     else if( opt.verbose )
360         log_info(_("original file name='%.*s'\n"), pt->namelen, pt->name);
361     free_md_filter_context( &c->mfx );
362     c->mfx.md = md_open( 0, 0);
363     /* fixme: we may need to push the textfilter if we have sigclass 1
364      * and no armoring - Not yet tested
365      * Hmmm, why don't we need it at all if we have sigclass 1
366      * Should we assume that plaintext in mode 't' has always sigclass 1??
367      * See: Russ Allbery's mail 1999-02-09
368      */
369     any = clearsig = only_md5 = 0;
370     for(n=c->list; n; n = n->next ) {
371         if( n->pkt->pkttype == PKT_ONEPASS_SIG ) {
372             if( n->pkt->pkt.onepass_sig->digest_algo ) {
373                 md_enable( c->mfx.md, n->pkt->pkt.onepass_sig->digest_algo );
374                 if( !any && n->pkt->pkt.onepass_sig->digest_algo
375                                                       == DIGEST_ALGO_MD5 )
376                     only_md5 = 1;
377                 else
378                     only_md5 = 0;
379                 any = 1;
380             }
381             if( n->pkt->pkt.onepass_sig->sig_class != 0x01 )
382                 only_md5 = 0;
383
384             /* Check whether this is a cleartext signature.  We assume that
385              * we have one if the sig_class is 1 and the keyid is 0, that
386              * are the faked packets produced by armor.c.  There is a
387              * possibility that this fails, but there is no other easy way
388              * to do it. (We could use a special packet type to indicate
389              * this, but this may also be faked - it simply can't be verified
390              * and is _no_ security issue)
391              */
392             if( n->pkt->pkt.onepass_sig->sig_class == 0x01
393                 && !n->pkt->pkt.onepass_sig->keyid[0]
394                 && !n->pkt->pkt.onepass_sig->keyid[1] )
395                 clearsig = 1;
396         }
397     }
398     if( !any ) { /* no onepass sig packet: enable all standard algos */
399         md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
400         md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
401         md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
402     }
403     if( only_md5 ) {
404         /* This is a kludge to work around a bug in pgp2.  It does only
405          * catch those mails which are armored.  To catch the non-armored
406          * pgp mails we could see whether there is the signature packet
407          * in front of the plaintext.  If someone needs this, send me a patch.
408          */
409         c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0);
410     }
411   #if 0
412     #warning md_start_debug is enabled
413     md_start_debug( c->mfx.md, "verify" );
414   #endif
415     rc = handle_plaintext( pt, &c->mfx, c->sigs_only, clearsig );
416     if( rc == G10ERR_CREATE_FILE && !c->sigs_only) {
417         /* can't write output but we hash it anyway to
418          * check the signature */
419         rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
420     }
421     if( rc )
422         log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
423     free_packet(pkt);
424     c->last_was_session_key = 0;
425 }
426
427
428 static int
429 proc_compressed_cb( IOBUF a, void *info )
430 {
431     return proc_signature_packets( info, a, ((CTX)info)->signed_data,
432                                             ((CTX)info)->sigfilename );
433 }
434
435 static int
436 proc_encrypt_cb( IOBUF a, void *info )
437 {
438     return proc_encryption_packets( info, a );
439 }
440
441 static void
442 proc_compressed( CTX c, PACKET *pkt )
443 {
444     PKT_compressed *zd = pkt->pkt.compressed;
445     int rc;
446
447     /*printf("zip: compressed data packet\n");*/
448     if( c->sigs_only )
449         rc = handle_compressed( c, zd, proc_compressed_cb, c );
450     else if( c->encrypt_only )
451         rc = handle_compressed( c, zd, proc_encrypt_cb, c );
452     else
453         rc = handle_compressed( c, zd, NULL, NULL );
454     if( rc )
455         log_error("uncompressing failed: %s\n", g10_errstr(rc));
456     free_packet(pkt);
457     c->last_was_session_key = 0;
458 }
459
460 /****************
461  * check the signature
462  * Returns: 0 = valid signature or an error code
463  */
464 static int
465 do_check_sig( CTX c, KBNODE node, int *is_selfsig )
466 {
467     PKT_signature *sig;
468     MD_HANDLE md = NULL, md2 = NULL;
469     int algo, rc;
470
471     assert( node->pkt->pkttype == PKT_SIGNATURE );
472     if( is_selfsig )
473         *is_selfsig = 0;
474     sig = node->pkt->pkt.signature;
475
476     algo = sig->digest_algo;
477     if( (rc=check_digest_algo(algo)) )
478         return rc;
479
480     if( sig->sig_class == 0x00 ) {
481         if( c->mfx.md )
482             md = md_copy( c->mfx.md );
483         else /* detached signature */
484             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
485     }
486     else if( sig->sig_class == 0x01 ) {
487         /* how do we know that we have to hash the (already hashed) text
488          * in canonical mode ??? (calculating both modes???) */
489         if( c->mfx.md ) {
490             md = md_copy( c->mfx.md );
491             if( c->mfx.md2 )
492                md2 = md_copy( c->mfx.md2 );
493         }
494         else { /* detached signature */
495           log_debug("Do we really need this here?");
496             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
497             md2 = md_open( 0, 0 );
498         }
499     }
500     else if( (sig->sig_class&~3) == 0x10
501              || sig->sig_class == 0x18
502              || sig->sig_class == 0x20
503              || sig->sig_class == 0x30  ) { /* classes 0x10..0x17,0x20,0x30 */
504         if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
505             || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
506             return check_key_signature( c->list, node, is_selfsig );
507         }
508         else {
509             log_error("invalid root packet for sigclass %02x\n",
510                                                         sig->sig_class);
511             return G10ERR_SIG_CLASS;
512         }
513     }
514     else
515         return G10ERR_SIG_CLASS;
516     rc = signature_check( sig, md );
517     if( rc == G10ERR_BAD_SIGN && md2 )
518         rc = signature_check( sig, md2 );
519     md_close(md);
520     md_close(md2);
521
522     return rc;
523 }
524
525
526 static void
527 print_userid( PACKET *pkt )
528 {
529     if( !pkt )
530         BUG();
531     if( pkt->pkttype != PKT_USER_ID ) {
532         printf("ERROR: unexpected packet type %d", pkt->pkttype );
533         return;
534     }
535     print_string( stdout,  pkt->pkt.user_id->name, pkt->pkt.user_id->len,
536                                                         opt.with_colons );
537 }
538
539
540 static void
541 print_fingerprint( PKT_public_key *pk, PKT_secret_key *sk )
542 {
543     byte array[MAX_FINGERPRINT_LEN], *p;
544     size_t i, n;
545
546     if( sk )
547         fingerprint_from_sk( sk, array, &n );
548     else
549         fingerprint_from_pk( pk, array, &n );
550     p = array;
551     if( opt.with_colons ) {
552         printf("fpr:::::::::");
553         for(i=0; i < n ; i++, p++ )
554             printf("%02X", *p );
555         putchar(':');
556     }
557     else {
558         printf("     Key fingerprint =");
559         if( n == 20 ) {
560             for(i=0; i < n ; i++, i++, p += 2 ) {
561                 if( i == 10 )
562                     putchar(' ');
563                 printf(" %02X%02X", *p, p[1] );
564             }
565         }
566         else {
567             for(i=0; i < n ; i++, p++ ) {
568                 if( i && !(i%8) )
569                     putchar(' ');
570                 printf(" %02X", *p );
571             }
572         }
573     }
574     putchar('\n');
575 }
576
577 static void
578 print_notation_data( PKT_signature *sig )
579 {
580     size_t n, n1, n2;
581     const byte *p;
582     int seq = 0;
583
584     while( (p = enum_sig_subpkt( sig->hashed_data, SIGSUBPKT_NOTATION,
585                                  &n, &seq )) ) {
586         if( n < 8 ) {
587             log_info(_("WARNING: invalid notation data found\n"));
588             return;
589         }
590         if( !(*p & 0x80) )
591             return; /* not human readable */
592         n1 = (p[4] << 8) | p[5];
593         n2 = (p[6] << 8) | p[7];
594         p += 8;
595         if( 8+n1+n2 != n ) {
596             log_info(_("WARNING: invalid notation data found\n"));
597             return;
598         }
599         log_info(_("Notation: ") );
600         print_string( log_stream(), p, n1, 0 );
601         putc( '=', log_stream() );
602         print_string( log_stream(), p+n1, n2, 0 );
603         putc( '\n', log_stream() );
604     }
605     if( (p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_POLICY, &n ) )) {
606         log_info(_("Policy: ") );
607         print_string( log_stream(), p, n, 0 );
608         putc( '\n', log_stream() );
609     }
610
611     /* Now check wheter the key of this signature has some
612      * notation data */
613
614     /* TODO */
615 }
616
617
618 /****************
619  * List the certificate in a user friendly way
620  */
621
622 static void
623 list_node( CTX c, KBNODE node )
624 {
625     int any=0;
626     int mainkey;
627
628     if( !node )
629         ;
630     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
631              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
632         PKT_public_key *pk = node->pkt->pkt.public_key;
633
634         if( opt.with_colons ) {
635             u32 keyid[2];
636             keyid_from_pk( pk, keyid );
637             if( mainkey ) {
638                 c->local_id = pk->local_id;
639                 c->trustletter = query_trust_info( pk, NULL );
640             }
641             printf("%s:%c:%u:%d:%08lX%08lX:%s:%s:",
642                     mainkey? "pub":"sub",
643                     c->trustletter,
644                     nbits_from_pk( pk ),
645                     pk->pubkey_algo,
646                     (ulong)keyid[0],(ulong)keyid[1],
647                     datestr_from_pk( pk ),
648                     pk->expiredate? strtimestamp(pk->expiredate):"" );
649             if( c->local_id )
650                 printf("%lu", c->local_id );
651             putchar(':');
652             if( c->local_id )
653                 putchar( get_ownertrust_info( c->local_id ) );
654             putchar(':');
655             if( node->next && node->next->pkt->pkttype == PKT_RING_TRUST) {
656                 putchar('\n'); any=1;
657                 if( opt.fingerprint )
658                     print_fingerprint( pk, NULL );
659                 printf("rtv:1:%u:\n",
660                             node->next->pkt->pkt.ring_trust->trustval );
661             }
662         }
663         else
664             printf("%s  %4u%c/%08lX %s ",
665                                       mainkey? "pub":"sub",
666                                       nbits_from_pk( pk ),
667                                       pubkey_letter( pk->pubkey_algo ),
668                                       (ulong)keyid_from_pk( pk, NULL ),
669                                       datestr_from_pk( pk )     );
670         if( mainkey ) {
671             /* and now list all userids with their signatures */
672             for( node = node->next; node; node = node->next ) {
673                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
674                     if( !any ) {
675                         if( node->pkt->pkt.signature->sig_class == 0x20 )
676                             puts("[revoked]");
677                         else
678                             putchar('\n');
679                         any = 1;
680                     }
681                     list_node(c,  node );
682                 }
683                 else if( node->pkt->pkttype == PKT_USER_ID ) {
684                     if( any ) {
685                         if( opt.with_colons )
686                             printf("uid:::::::::");
687                         else
688                             printf( "uid%*s", 28, "" );
689                     }
690                     print_userid( node->pkt );
691                     if( opt.with_colons )
692                         putchar(':');
693                     putchar('\n');
694                     if( opt.fingerprint && !any )
695                         print_fingerprint( pk, NULL );
696                     if( node->next
697                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
698                         printf("rtv:2:%u:\n",
699                                  node->next->pkt->pkt.ring_trust->trustval );
700                     }
701                     any=1;
702                 }
703                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
704                     if( !any ) {
705                         putchar('\n');
706                         any = 1;
707                     }
708                     list_node(c,  node );
709                 }
710             }
711         }
712         if( !any )
713             putchar('\n');
714         if( !mainkey && opt.fingerprint > 1 )
715             print_fingerprint( pk, NULL );
716     }
717     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
718              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
719         PKT_secret_key *sk = node->pkt->pkt.secret_key;
720
721         if( opt.with_colons ) {
722             u32 keyid[2];
723             keyid_from_sk( sk, keyid );
724             printf("%s::%u:%d:%08lX%08lX:%s:%s:::",
725                     mainkey? "sec":"ssb",
726                     nbits_from_sk( sk ),
727                     sk->pubkey_algo,
728                     (ulong)keyid[0],(ulong)keyid[1],
729                     datestr_from_sk( sk ),
730                     sk->expiredate? strtimestamp(sk->expiredate):""
731                     /* fixme: add LID */ );
732         }
733         else
734             printf("%s  %4u%c/%08lX %s ",
735                                       mainkey? "sec":"ssb",
736                                       nbits_from_sk( sk ),
737                                       pubkey_letter( sk->pubkey_algo ),
738                                       (ulong)keyid_from_sk( sk, NULL ),
739                                       datestr_from_sk( sk )   );
740         if( mainkey ) {
741             /* and now list all userids with their signatures */
742             for( node = node->next; node; node = node->next ) {
743                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
744                     if( !any ) {
745                         if( node->pkt->pkt.signature->sig_class == 0x20 )
746                             puts("[revoked]");
747                         else
748                             putchar('\n');
749                         any = 1;
750                     }
751                     list_node(c,  node );
752                 }
753                 else if( node->pkt->pkttype == PKT_USER_ID ) {
754                     if( any ) {
755                         if( opt.with_colons )
756                             printf("uid:::::::::");
757                         else
758                             printf( "uid%*s", 28, "" );
759                     }
760                     print_userid( node->pkt );
761                     if( opt.with_colons )
762                         putchar(':');
763                     putchar('\n');
764                     if( opt.fingerprint && !any )
765                         print_fingerprint( NULL, sk );
766                     any=1;
767                 }
768                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
769                     if( !any ) {
770                         putchar('\n');
771                         any = 1;
772                     }
773                     list_node(c,  node );
774                 }
775             }
776         }
777         if( !any )
778             putchar('\n');
779         if( !mainkey && opt.fingerprint > 1 )
780             print_fingerprint( NULL, sk );
781     }
782     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
783         PKT_signature *sig = node->pkt->pkt.signature;
784         int is_selfsig = 0;
785         int rc2=0;
786         size_t n;
787         char *p;
788         int sigrc = ' ';
789
790         if( !opt.list_sigs )
791             return;
792
793         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
794             fputs("rev", stdout);
795         else
796             fputs("sig", stdout);
797         if( opt.check_sigs ) {
798             fflush(stdout);
799             switch( (rc2=do_check_sig( c, node, &is_selfsig )) ) {
800               case 0:                  sigrc = '!'; break;
801               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
802               case G10ERR_NO_PUBKEY:   sigrc = '?'; break;
803               default:                 sigrc = '%'; break;
804             }
805         }
806         else {  /* check whether this is a self signature */
807             u32 keyid[2];
808
809             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
810                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
811                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
812                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
813                 else
814                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
815
816                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
817                     is_selfsig = 1;
818             }
819         }
820         if( opt.with_colons ) {
821             putchar(':');
822             if( sigrc != ' ' )
823                 putchar(sigrc);
824             printf(":::%08lX%08lX:%s::::", (ulong)sig->keyid[0],
825                        (ulong)sig->keyid[1], datestr_from_sig(sig));
826         }
827         else
828             printf("%c       %08lX %s   ",
829                     sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
830         if( sigrc == '%' )
831             printf("[%s] ", g10_errstr(rc2) );
832         else if( sigrc == '?' )
833             ;
834         else if( is_selfsig ) {
835             if( opt.with_colons )
836                 putchar(':');
837             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
838             if( opt.with_colons )
839                 putchar(':');
840         }
841         else {
842             p = get_user_id( sig->keyid, &n );
843             print_string( stdout, p, n, opt.with_colons );
844             m_free(p);
845         }
846         if( opt.with_colons )
847             printf(":%02x:", sig->sig_class );
848         putchar('\n');
849     }
850     else
851         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
852 }
853
854
855 int
856 proc_packets( void *anchor, IOBUF a )
857 {
858     int rc;
859     CTX c = m_alloc_clear( sizeof *c );
860
861     c->anchor = anchor;
862     rc = do_proc_packets( c, a );
863     m_free( c );
864     return rc;
865 }
866
867 int
868 proc_signature_packets( void *anchor, IOBUF a,
869                         STRLIST signedfiles, const char *sigfilename )
870 {
871     CTX c = m_alloc_clear( sizeof *c );
872     int rc;
873
874     c->anchor = anchor;
875     c->sigs_only = 1;
876     c->signed_data = signedfiles;
877     c->sigfilename = sigfilename;
878     rc = do_proc_packets( c, a );
879     m_free( c );
880     return rc;
881 }
882
883 int
884 proc_encryption_packets( void *anchor, IOBUF a )
885 {
886     CTX c = m_alloc_clear( sizeof *c );
887     int rc;
888
889     c->anchor = anchor;
890     c->encrypt_only = 1;
891     rc = do_proc_packets( c, a );
892     m_free( c );
893     return rc;
894 }
895
896
897 int
898 do_proc_packets( CTX c, IOBUF a )
899 {
900     PACKET *pkt = m_alloc( sizeof *pkt );
901     int rc=0;
902     int any_data=0;
903     int newpkt;
904
905     c->iobuf = a;
906     init_packet(pkt);
907     while( (rc=parse_packet(a, pkt)) != -1 ) {
908         any_data = 1;
909         if( rc ) {
910             free_packet(pkt);
911             if( rc == G10ERR_INVALID_PACKET )
912                 break;
913             continue;
914         }
915         newpkt = -1;
916         if( opt.list_packets ) {
917             switch( pkt->pkttype ) {
918               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
919               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
920               case PKT_ENCRYPTED:
921               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
922               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
923               default: newpkt = 0; break;
924             }
925         }
926         else if( c->sigs_only ) {
927             switch( pkt->pkttype ) {
928               case PKT_PUBLIC_KEY:
929               case PKT_SECRET_KEY:
930               case PKT_USER_ID:
931               case PKT_SYMKEY_ENC:
932               case PKT_PUBKEY_ENC:
933               case PKT_ENCRYPTED:
934               case PKT_ENCRYPTED_MDC:
935                 rc = G10ERR_UNEXPECTED;
936                 goto leave;
937               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
938               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
939               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
940               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
941               default: newpkt = 0; break;
942             }
943         }
944         else if( c->encrypt_only ) {
945             switch( pkt->pkttype ) {
946               case PKT_PUBLIC_KEY:
947               case PKT_SECRET_KEY:
948               case PKT_USER_ID:
949                 rc = G10ERR_UNEXPECTED;
950                 goto leave;
951               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
952               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
953               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
954               case PKT_ENCRYPTED:
955               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
956               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
957               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
958               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
959               default: newpkt = 0; break;
960             }
961         }
962         else {
963             switch( pkt->pkttype ) {
964               case PKT_PUBLIC_KEY:
965               case PKT_SECRET_KEY:
966                 release_list( c );
967                 c->list = new_kbnode( pkt );
968                 newpkt = 1;
969                 break;
970               case PKT_PUBLIC_SUBKEY:
971               case PKT_SECRET_SUBKEY:
972                 newpkt = add_subkey( c, pkt );
973                 break;
974               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
975               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
976               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
977               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
978               case PKT_ENCRYPTED:
979               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
980               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
981               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
982               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
983               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
984               default: newpkt = 0; break;
985             }
986         }
987         if( pkt->pkttype != PKT_SIGNATURE )
988             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
989
990         if( newpkt == -1 )
991             ;
992         else if( newpkt ) {
993             pkt = m_alloc( sizeof *pkt );
994             init_packet(pkt);
995         }
996         else
997             free_packet(pkt);
998     }
999     if( rc == G10ERR_INVALID_PACKET )
1000         write_status_text( STATUS_NODATA, "3" );
1001     if( any_data )
1002         rc = 0;
1003     else if( rc == -1 )
1004         write_status_text( STATUS_NODATA, "2" );
1005
1006
1007   leave:
1008     release_list( c );
1009     m_free(c->dek);
1010     free_packet( pkt );
1011     m_free( pkt );
1012     free_md_filter_context( &c->mfx );
1013     return rc;
1014 }
1015
1016
1017 static int
1018 check_sig_and_print( CTX c, KBNODE node )
1019 {
1020     PKT_signature *sig = node->pkt->pkt.signature;
1021     const char *astr, *tstr;
1022     int rc;
1023
1024     if( opt.skip_verify ) {
1025         log_info(_("signature verification suppressed\n"));
1026         return 0;
1027     }
1028
1029     tstr = asctimestamp(sig->timestamp);
1030     astr = pubkey_algo_to_string( sig->pubkey_algo );
1031     log_info(_("Signature made %.*s using %s key ID %08lX\n"),
1032             (int)strlen(tstr), tstr, astr? astr: "?", (ulong)sig->keyid[1] );
1033
1034     rc = do_check_sig(c, node, NULL );
1035     if( rc == G10ERR_NO_PUBKEY && opt.keyserver_name ) {
1036         if( !hkp_ask_import( sig->keyid ) )
1037             rc = do_check_sig(c, node, NULL );
1038     }
1039     if( !rc || rc == G10ERR_BAD_SIGN ) {
1040         KBNODE un, keyblock;
1041         char *us;
1042         int count=0;
1043
1044         keyblock = get_pubkeyblock( sig->keyid );
1045
1046         us = get_long_user_id_string( sig->keyid );
1047         write_status_text( rc? STATUS_BADSIG : STATUS_GOODSIG, us );
1048         m_free(us);
1049
1050         /* fixme: list only user ids which are valid and add information
1051          *        about the trustworthiness of each user id, sort them.
1052          *        Integrate this with check_signatures_trust(). */
1053         for( un=keyblock; un; un = un->next ) {
1054             if( un->pkt->pkttype != PKT_USER_ID )
1055                 continue;
1056             if( !count++ )
1057                 log_info(rc? _("BAD signature from \"")
1058                            : _("Good signature from \""));
1059             else
1060                 log_info(    _("                aka \""));
1061             print_utf8_string( log_stream(), un->pkt->pkt.user_id->name,
1062                                              un->pkt->pkt.user_id->len );
1063             fputs("\"\n", log_stream() );
1064             if( rc )
1065                 break; /* print only one id in this case */
1066         }
1067         if( !count ) {  /* just in case that we have no userid */
1068             log_info(rc? _("BAD signature from \"")
1069                        : _("Good signature from \""));
1070             fputs("[?]\"\n", log_stream() );
1071         }
1072         release_kbnode( keyblock );
1073         if( !rc )
1074             print_notation_data( sig );
1075
1076         if( !rc && is_status_enabled() ) {
1077             /* print a status response with the fingerprint */
1078             PKT_public_key *pk = m_alloc_clear( sizeof *pk );
1079
1080             if( !get_pubkey( pk, sig->keyid ) ) {
1081                 byte array[MAX_FINGERPRINT_LEN], *p;
1082                 char buf[MAX_FINGERPRINT_LEN*2+61];
1083                 size_t i, n;
1084
1085                 fingerprint_from_pk( pk, array, &n );
1086                 p = array;
1087                 for(i=0; i < n ; i++, p++ )
1088                     sprintf(buf+2*i, "%02X", *p );
1089                 sprintf(buf+strlen(buf), " %s %lu",
1090                                          strtimestamp( sig->timestamp ),
1091                                          (ulong)sig->timestamp );
1092                 write_status_text( STATUS_VALIDSIG, buf );
1093             }
1094             free_public_key( pk );
1095         }
1096
1097         if( !rc )
1098             rc = check_signatures_trust( sig );
1099         if( rc )
1100             g10_errors_seen = 1;
1101         if( opt.batch && rc )
1102             g10_exit(1);
1103     }
1104     else {
1105         char buf[50];
1106         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1107                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1108                      sig->pubkey_algo, sig->digest_algo,
1109                      sig->sig_class, (ulong)sig->timestamp, rc );
1110         write_status_text( STATUS_ERRSIG, buf );
1111         if( rc == G10ERR_NO_PUBKEY ) {
1112             buf[16] = 0;
1113             write_status_text( STATUS_NO_PUBKEY, buf );
1114         }
1115         log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1116     }
1117     return rc;
1118 }
1119
1120
1121 /****************
1122  * Process the tree which starts at node
1123  */
1124 static void
1125 proc_tree( CTX c, KBNODE node )
1126 {
1127     KBNODE n1;
1128     int rc;
1129
1130     if( opt.list_packets )
1131         return;
1132
1133     c->local_id = 0;
1134     c->trustletter = ' ';
1135     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1136         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1137         merge_keys_and_selfsig( node );
1138         list_node( c, node );
1139     }
1140     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1141         merge_keys_and_selfsig( node );
1142         list_node( c, node );
1143     }
1144     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1145         /* check all signatures */
1146         if( !c->have_data ) {
1147             free_md_filter_context( &c->mfx );
1148             /* prepare to create all requested message digests */
1149             c->mfx.md = md_open(0, 0);
1150
1151             /* fixme: why looking for the signature packet and not 1passpacket*/
1152             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1153                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1154             }
1155             /* ask for file and hash it */
1156             if( c->sigs_only )
1157                 rc = hash_datafiles( c->mfx.md, NULL,
1158                                      c->signed_data, c->sigfilename,
1159                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1160             else
1161                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1162                                             iobuf_get_fname(c->iobuf), 0 );
1163             if( rc ) {
1164                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1165                 return;
1166             }
1167         }
1168
1169         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1170             check_sig_and_print( c, n1 );
1171     }
1172     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1173         PKT_signature *sig = node->pkt->pkt.signature;
1174
1175         if( !c->have_data ) {
1176             /* detached signature */
1177             free_md_filter_context( &c->mfx );
1178             c->mfx.md = md_open(sig->digest_algo, 0);
1179             if( sig->digest_algo == DIGEST_ALGO_MD5
1180                 && is_RSA( sig->pubkey_algo ) ) {
1181                 /* enable a workaround for a pgp2 bug */
1182                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1183             }
1184             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1185                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1186                      && sig->sig_class == 0x01 ) {
1187                 /* enable the workaround also for pgp5 when the detached
1188                  * signature has been created in textmode */
1189                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1190             }
1191             /* Here we have another hack to work around a pgp 2 bug
1192              * It works by not using the textmode for detached signatures;
1193              * this will let the first signature check (on md) fail
1194              * but the second one (on md2) which adds an extra CR should
1195              * then produce the "correct" hash.  This is very, very ugly
1196              * hack but it may help in some cases (and break others)
1197              */
1198             if( c->sigs_only )
1199                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
1200                                      c->signed_data, c->sigfilename,
1201                                      c->mfx.md2? 0 :(sig->sig_class == 0x01) );
1202             else
1203                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1204                                          iobuf_get_fname(c->iobuf),
1205                                c->mfx.md2? 0 :(sig->sig_class == 0x01) );
1206             if( rc ) {
1207                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1208                 return;
1209             }
1210         }
1211         else
1212             log_info(_("old style (PGP 2.x) signature\n"));
1213
1214         check_sig_and_print( c, node );
1215     }
1216     else
1217         log_error(_("invalid root packet detected in proc_tree()\n"));
1218
1219 }
1220
1221
1222