g10/mainproc.c

   1 /* mainproc.c - handle packets
   2  *      Copyright (C) 1998 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 "cipher.h"
  37 #include "main.h"
  38 #include "status.h"
  39 #include "i18n.h"
  40 #include "trustdb.h"
  41
  42 /****************
  43  * Structure to hold the context
  44  */
  45
  46 typedef struct {
  47     PKT_public_key *last_pubkey;
  48     PKT_secret_key *last_seckey;
  49     PKT_user_id     *last_user_id;
  50     md_filter_context_t mfx;
  51     int sigs_only;   /* process only signatures and reject all other stuff */
  52     int encrypt_only; /* process only encrytion messages */
  53     STRLIST signed_data;
  54     const char *sigfilename;
  55     DEK *dek;
  56     int last_was_session_key;
  57     KBNODE list;   /* the current list of packets */
  58     int have_data;
  59     IOBUF iobuf;    /* used to get the filename etc. */
  60     int trustletter; /* temp usage in list_node */
  61     ulong local_id;    /* ditto */
  62 } *CTX;
  63
  64
  65 static int do_proc_packets( CTX c, IOBUF a );
  66
  67 static void list_node( CTX c, KBNODE node );
  68 static void proc_tree( CTX c, KBNODE node );
  69
  70
  71 static void
  72 release_list( CTX c )
  73 {
  74     if( !c->list )
  75         return;
  76     proc_tree(c, c->list );
  77     release_kbnode( c->list );
  78     c->list = NULL;
  79 }
  80
  81
  82 static int
  83 add_onepass_sig( CTX c, PACKET *pkt )
  84 {
  85     KBNODE node;
  86
  87     if( c->list ) { /* add another packet */
  88         if( c->list->pkt->pkttype != PKT_ONEPASS_SIG ) {
  89            log_error("add_onepass_sig: another packet is in the way\n");
  90            release_list( c );
  91            c->list = new_kbnode( pkt );
  92         }
  93         else
  94            add_kbnode( c->list, new_kbnode( pkt ));
  95     }
  96     else /* insert the first one */
  97         c->list = node = new_kbnode( pkt );
  98
  99     return 1;
 100 }
 101
 102
 103
 104 static int
 105 add_user_id( CTX c, PACKET *pkt )
 106 {
 107     if( !c->list ) {
 108         log_error("orphaned user id\n" );
 109         return 0;
 110     }
 111     add_kbnode( c->list, new_kbnode( pkt ) );
 112     return 1;
 113 }
 114
 115 static int
 116 add_subkey( CTX c, PACKET *pkt )
 117 {
 118     if( !c->list ) {
 119         log_error("subkey w/o mainkey\n" );
 120         return 0;
 121     }
 122     add_kbnode( c->list, new_kbnode( pkt ) );
 123     return 1;
 124 }
 125
 126
 127 static int
 128 add_signature( CTX c, PACKET *pkt )
 129 {
 130     KBNODE node;
 131
 132     if( pkt->pkttype == PKT_SIGNATURE && !c->list ) {
 133         /* This is the first signature for the following datafile.
 134          * G10 does not write such packets; instead it always uses
 135          * onepass-sig packets.  The drawback of PGP's method
 136          * of prepending the signature to the data is
 137          * that it is not possible to make a signature from data read
 138          * from stdin.  (G10 is able to read PGP stuff anyway.) */
 139         node = new_kbnode( pkt );
 140         c->list = node;
 141         return 1;
 142     }
 143     else if( !c->list )
 144         return 0; /* oops (invalid packet sequence)*/
 145     else if( !c->list->pkt )
 146         BUG();  /* so nicht */
 147
 148     /* add a new signature node id at the end */
 149     node = new_kbnode( pkt );
 150     add_kbnode( c->list, node );
 151     return 1;
 152 }
 153
 154
 155 static void
 156 proc_symkey_enc( CTX c, PACKET *pkt )
 157 {
 158     PKT_symkey_enc *enc;
 159
 160     enc = pkt->pkt.symkey_enc;
 161     if( enc->seskeylen )
 162         log_error( "symkey_enc packet with session keys are not supported!\n");
 163     else {
 164         c->last_was_session_key = 2;
 165         c->dek = passphrase_to_dek( NULL, enc->cipher_algo, &enc->s2k, 0 );
 166     }
 167     free_packet(pkt);
 168 }
 169
 170 static void
 171 proc_pubkey_enc( CTX c, PACKET *pkt )
 172 {
 173     PKT_pubkey_enc *enc;
 174     int result = 0;
 175
 176     /* check whether the secret key is available and store in this case */
 177     c->last_was_session_key = 1;
 178     enc = pkt->pkt.pubkey_enc;
 179     /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
 180     if( is_ELGAMAL(enc->pubkey_algo)
 181         || enc->pubkey_algo == PUBKEY_ALGO_DSA
 182         || is_RSA(enc->pubkey_algo)  ) {
 183         m_free(c->dek ); /* paranoid: delete a pending DEK */
 184         c->dek = m_alloc_secure( sizeof *c->dek );
 185         if( (result = get_session_key( enc, c->dek )) ) {
 186             /* error: delete the DEK */
 187             m_free(c->dek); c->dek = NULL;
 188         }
 189     }
 190     else
 191         result = G10ERR_PUBKEY_ALGO;
 192
 193     if( result == -1 )
 194         ;
 195     else if( !result ) {
 196         if( opt.verbose > 1 )
 197             log_info( "pubkey_enc packet: Good DEK\n" );
 198     }
 199     else {
 200         log_error(_("public key decryption failed: %s\n"), g10_errstr(result));
 201     }
 202     free_packet(pkt);
 203 }
 204
 205
 206 static void
 207 proc_encrypted( CTX c, PACKET *pkt )
 208 {
 209     int result = 0;
 210
 211     /*printf("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
 212     if( !c->dek && !c->last_was_session_key ) {
 213         /* assume this is old conventional encrypted data */
 214         c->dek = passphrase_to_dek( NULL,
 215                     opt.def_cipher_algo ? opt.def_cipher_algo
 216                                         : DEFAULT_CIPHER_ALGO, NULL, 0 );
 217     }
 218     else if( !c->dek )
 219         result = G10ERR_NO_SECKEY;
 220     if( !result )
 221         result = decrypt_data( pkt->pkt.encrypted, c->dek );
 222     m_free(c->dek); c->dek = NULL;
 223     if( result == -1 )
 224         ;
 225     else if( !result ) {
 226         if( opt.verbose > 1 )
 227             log_info("decryption okay\n");
 228     }
 229     else {
 230         log_error(_("decryption failed: %s\n"), g10_errstr(result));
 231         /* FIXME: if this is secret key not available, try with
 232          * other keys */
 233     }
 234     free_packet(pkt);
 235     c->last_was_session_key = 0;
 236 }
 237
 238
 239 static void
 240 proc_plaintext( CTX c, PACKET *pkt )
 241 {
 242     PKT_plaintext *pt = pkt->pkt.plaintext;
 243     int any, clearsig, rc;
 244     KBNODE n;
 245
 246     if( opt.verbose )
 247         log_info("original file name='%.*s'\n", pt->namelen, pt->name);
 248     free_md_filter_context( &c->mfx );
 249     c->mfx.md = md_open( 0, 0);
 250     /* fixme: we may need to push the textfilter if we have sigclass 1
 251      * and no armoring - Not yet tested */
 252     any = clearsig = 0;
 253     for(n=c->list; n; n = n->next ) {
 254         if( n->pkt->pkttype == PKT_ONEPASS_SIG ) {
 255             if( n->pkt->pkt.onepass_sig->digest_algo ) {
 256                 md_enable( c->mfx.md, n->pkt->pkt.onepass_sig->digest_algo );
 257                 any = 1;
 258             }
 259             /* Check whether this is a cleartext signature.  We assume that
 260              * we have one if the sig_class is 1 and the keyid is 0, that
 261              * are the faked packets produced by armor.c.  There is a
 262              * possibility that this fails, but there is no other easy way
 263              * to do it. (We could use a special packet type to indicate
 264              * this, but this may also be faked - it simply can't be verified
 265              * and is _no_ security issue)
 266              */
 267             if( n->pkt->pkt.onepass_sig->sig_class == 0x01
 268                 && !n->pkt->pkt.onepass_sig->keyid[0]
 269                 && !n->pkt->pkt.onepass_sig->keyid[1]  )
 270                 clearsig = 1;
 271         }
 272     }
 273     if( !any ) { /* no onepass sig packet: enable all standard algos */
 274         md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
 275         md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
 276         md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
 277     }
 278     if( c->mfx.md ) {
 279         m_check(c->mfx.md);
 280         if( c->mfx.md->list )
 281             m_check( c->mfx.md->list );
 282     }
 283     rc = handle_plaintext( pt, &c->mfx, c->sigs_only, clearsig );
 284     if( rc == G10ERR_CREATE_FILE && !c->sigs_only) {
 285         /* can't write output but we hash it anyway to
 286          * check the signature */
 287         rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
 288     }
 289     if( rc )
 290         log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
 291     free_packet(pkt);
 292     c->last_was_session_key = 0;
 293 }
 294
 295
 296 static int
 297 proc_compressed_cb( IOBUF a, void *info )
 298 {
 299     return proc_signature_packets( a, ((CTX)info)->signed_data,
 300                                       ((CTX)info)->sigfilename );
 301 }
 302
 303 static int
 304 proc_encrypt_cb( IOBUF a, void *info )
 305 {
 306     return proc_encryption_packets( a );
 307 }
 308
 309 static void
 310 proc_compressed( CTX c, PACKET *pkt )
 311 {
 312     PKT_compressed *zd = pkt->pkt.compressed;
 313     int rc;
 314
 315     /*printf("zip: compressed data packet\n");*/
 316     if( c->sigs_only )
 317         rc = handle_compressed( zd, proc_compressed_cb, c );
 318     else if( c->encrypt_only )
 319         rc = handle_compressed( zd, proc_encrypt_cb, c );
 320     else
 321         rc = handle_compressed( zd, NULL, NULL );
 322     if( rc )
 323         log_error("uncompressing failed: %s\n", g10_errstr(rc));
 324     free_packet(pkt);
 325     c->last_was_session_key = 0;
 326 }
 327
 328
 329
 330
 331 /****************
 332  * check the signature
 333  * Returns: 0 = valid signature or an error code
 334  */
 335 static int
 336 do_check_sig( CTX c, KBNODE node, int *is_selfsig )
 337 {
 338     PKT_signature *sig;
 339     MD_HANDLE md;
 340     int algo, rc;
 341
 342     assert( node->pkt->pkttype == PKT_SIGNATURE );
 343     if( is_selfsig )
 344         *is_selfsig = 0;
 345     sig = node->pkt->pkt.signature;
 346
 347     algo = sig->digest_algo;
 348     if( !algo )
 349         return G10ERR_PUBKEY_ALGO;
 350     if( (rc=check_digest_algo(algo)) )
 351         return rc;
 352
 353     if( c->mfx.md ) {
 354         m_check(c->mfx.md);
 355         if( c->mfx.md->list )
 356             m_check( c->mfx.md->list );
 357     }
 358
 359     if( sig->sig_class == 0x00 ) {
 360         if( c->mfx.md )
 361             md = md_copy( c->mfx.md );
 362         else /* detached signature */
 363             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
 364     }
 365     else if( sig->sig_class == 0x01 ) {
 366         /* how do we know that we have to hash the (already hashed) text
 367          * in canonical mode ??? (calculating both modes???) */
 368         if( c->mfx.md )
 369             md = md_copy( c->mfx.md );
 370         else /* detached signature */
 371             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
 372     }
 373     else if( (sig->sig_class&~3) == 0x10
 374              || sig->sig_class == 0x18
 375              || sig->sig_class == 0x20
 376              || sig->sig_class == 0x30  ) { /* classes 0x10..0x17,0x20,0x30 */
 377         if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
 378             || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
 379             return check_key_signature( c->list, node, is_selfsig );
 380         }
 381         else {
 382             log_error("invalid root packet for sigclass %02x\n",
 383                                                         sig->sig_class);
 384             return G10ERR_SIG_CLASS;
 385         }
 386     }
 387     else
 388         return G10ERR_SIG_CLASS;
 389     rc = signature_check( sig, md );
 390     md_close(md);
 391
 392     return rc;
 393 }
 394
 395
 396
 397 static void
 398 print_userid( PACKET *pkt )
 399 {
 400     if( !pkt )
 401         BUG();
 402     if( pkt->pkttype != PKT_USER_ID ) {
 403         printf("ERROR: unexpected packet type %d", pkt->pkttype );
 404         return;
 405     }
 406     print_string( stdout,  pkt->pkt.user_id->name, pkt->pkt.user_id->len,
 407                                                         opt.with_colons );
 408 }
 409
 410
 411 static void
 412 print_fingerprint( PKT_public_key *pk, PKT_secret_key *sk )
 413 {
 414     byte *array, *p;
 415     size_t i, n;
 416
 417     p = array = sk? fingerprint_from_sk( sk, NULL, &n )
 418                    : fingerprint_from_pk( pk, NULL, &n );
 419     if( opt.with_colons ) {
 420         printf("fpr:::::::::");
 421         for(i=0; i < n ; i++, p++ )
 422             printf("%02X", *p );
 423         putchar(':');
 424     }
 425     else {
 426         printf("     Key fingerprint =");
 427         if( n == 20 ) {
 428             for(i=0; i < n ; i++, i++, p += 2 ) {
 429                 if( i == 10 )
 430                     putchar(' ');
 431                 printf(" %02X%02X", *p, p[1] );
 432             }
 433         }
 434         else {
 435             for(i=0; i < n ; i++, p++ ) {
 436                 if( i && !(i%8) )
 437                     putchar(' ');
 438                 printf(" %02X", *p );
 439             }
 440         }
 441     }
 442     putchar('\n');
 443     m_free(array);
 444 }
 445
 446
 447 /****************
 448  * List the certificate in a user friendly way
 449  */
 450
 451 static void
 452 list_node( CTX c, KBNODE node )
 453 {
 454     int any=0;
 455     int mainkey;
 456
 457     if( !node )
 458         ;
 459     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
 460              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
 461         PKT_public_key *pk = node->pkt->pkt.public_key;
 462
 463         if( opt.with_colons ) {
 464             u32 keyid[2];
 465             keyid_from_pk( pk, keyid );
 466             if( mainkey ) {
 467                 c->local_id = pk->local_id;
 468                 c->trustletter = query_trust_info( pk );
 469             }
 470             printf("%s:%c:%u:%d:%08lX%08lX:%s:%u:",
 471                     mainkey? "pub":"sub",
 472                     c->trustletter,
 473                     nbits_from_pk( pk ),
 474                     pk->pubkey_algo,
 475                     (ulong)keyid[0],(ulong)keyid[1],
 476                     datestr_from_pk( pk ),
 477                     (unsigned)pk->valid_days );
 478             if( c->local_id )
 479                 printf("%lu", c->local_id );
 480             putchar(':');
 481             /* fixme: add ownertrust here */
 482             putchar(':');
 483         }
 484         else
 485             printf("%s  %4u%c/%08lX %s ",
 486                                       mainkey? "pub":"sub",
 487                                       nbits_from_pk( pk ),
 488                                       pubkey_letter( pk->pubkey_algo ),
 489                                       (ulong)keyid_from_pk( pk, NULL ),
 490                                       datestr_from_pk( pk )     );
 491         if( mainkey ) {
 492             /* and now list all userids with their signatures */
 493             for( node = node->next; node; node = node->next ) {
 494                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
 495                     if( !any ) {
 496                         if( node->pkt->pkt.signature->sig_class == 0x20 )
 497                             puts("[revoked]");
 498                         else
 499                             putchar('\n');
 500                         any = 1;
 501                     }
 502                     list_node(c,  node );
 503                 }
 504                 else if( node->pkt->pkttype == PKT_USER_ID ) {
 505                     if( any ) {
 506                         if( opt.with_colons )
 507                             printf("uid:::::::::");
 508                         else
 509                             printf( "uid%*s", 28, "" );
 510                     }
 511                     print_userid( node->pkt );
 512                     if( opt.with_colons )
 513                         putchar(':');
 514                     putchar('\n');
 515                     if( opt.fingerprint && !any )
 516                         print_fingerprint( pk, NULL );
 517                     any=1;
 518                 }
 519                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
 520                     if( !any ) {
 521                         putchar('\n');
 522                         any = 1;
 523                     }
 524                     list_node(c,  node );
 525                 }
 526             }
 527         }
 528         if( !any )
 529             putchar('\n');
 530         if( !mainkey && opt.fingerprint > 1 )
 531             print_fingerprint( pk, NULL );
 532     }
 533     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
 534              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
 535         PKT_secret_key *sk = node->pkt->pkt.secret_key;
 536
 537         if( opt.with_colons ) {
 538             u32 keyid[2];
 539             keyid_from_sk( sk, keyid );
 540             printf("%s::%u:%d:%08lX%08lX:%s:%u:::",
 541                     mainkey? "sec":"ssb",
 542                     nbits_from_sk( sk ),
 543                     sk->pubkey_algo,
 544                     (ulong)keyid[0],(ulong)keyid[1],
 545                     datestr_from_sk( sk ),
 546                     (unsigned)sk->valid_days
 547                     /* fixme: add LID */ );
 548         }
 549         else
 550             printf("%s  %4u%c/%08lX %s ",
 551                                       mainkey? "sec":"ssb",
 552                                       nbits_from_sk( sk ),
 553                                       pubkey_letter( sk->pubkey_algo ),
 554                                       (ulong)keyid_from_sk( sk, NULL ),
 555                                       datestr_from_sk( sk )   );
 556         if( mainkey ) {
 557             /* and now list all userids with their signatures */
 558             for( node = node->next; node; node = node->next ) {
 559                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
 560                     if( !any ) {
 561                         if( node->pkt->pkt.signature->sig_class == 0x20 )
 562                             puts("[revoked]");
 563                         else
 564                             putchar('\n');
 565                         any = 1;
 566                     }
 567                     list_node(c,  node );
 568                 }
 569                 else if( node->pkt->pkttype == PKT_USER_ID ) {
 570                     if( any ) {
 571                         if( opt.with_colons )
 572                             printf("uid:::::::::");
 573                         else
 574                             printf( "uid%*s", 28, "" );
 575                     }
 576                     print_userid( node->pkt );
 577                     if( opt.with_colons )
 578                         putchar(':');
 579                     putchar('\n');
 580                     if( opt.fingerprint && !any )
 581                         print_fingerprint( NULL, sk );
 582                     any=1;
 583                 }
 584                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
 585                     if( !any ) {
 586                         putchar('\n');
 587                         any = 1;
 588                     }
 589                     list_node(c,  node );
 590                 }
 591             }
 592         }
 593         if( !any )
 594             putchar('\n');
 595         if( !mainkey && opt.fingerprint > 1 )
 596             print_fingerprint( NULL, sk );
 597     }
 598     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
 599         PKT_signature *sig = node->pkt->pkt.signature;
 600         int is_selfsig = 0;
 601         int rc2=0;
 602         size_t n;
 603         char *p;
 604         int sigrc = ' ';
 605
 606         if( !opt.list_sigs )
 607             return;
 608
 609         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
 610             fputs("rev", stdout);
 611         else
 612             fputs("sig", stdout);
 613         if( opt.check_sigs ) {
 614             fflush(stdout);
 615             switch( (rc2=do_check_sig( c, node, &is_selfsig )) ) {
 616               case 0:                  sigrc = '!'; break;
 617               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
 618               case G10ERR_NO_PUBKEY:   sigrc = '?'; break;
 619               default:                 sigrc = '%'; break;
 620             }
 621         }
 622         else {  /* check whether this is a self signature */
 623             u32 keyid[2];
 624
 625             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
 626                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
 627                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
 628                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
 629                 else
 630                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
 631
 632                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
 633                     is_selfsig = 1;
 634             }
 635         }
 636         if( opt.with_colons ) {
 637             putchar(':');
 638             if( sigrc != ' ' )
 639                 putchar(sigrc);
 640             printf(":::%08lX%08lX:%s::::", (ulong)sig->keyid[0],
 641                        (ulong)sig->keyid[1], datestr_from_sig(sig));
 642         }
 643         else
 644             printf("%c       %08lX %s   ",
 645                     sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
 646         if( sigrc == '%' )
 647             printf("[%s] ", g10_errstr(rc2) );
 648         else if( sigrc == '?' )
 649             ;
 650         else if( is_selfsig ) {
 651             if( opt.with_colons )
 652                 putchar(':');
 653             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
 654             if( opt.with_colons )
 655                 putchar(':');
 656         }
 657         else {
 658             p = get_user_id( sig->keyid, &n );
 659             print_string( stdout, p, n, opt.with_colons );
 660             m_free(p);
 661         }
 662         if( opt.with_colons )
 663             printf(":%02x:", sig->sig_class );
 664         putchar('\n');
 665     }
 666     else
 667         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
 668 }
 669
 670
 671 int
 672 proc_packets( IOBUF a )
 673 {
 674     CTX c = m_alloc_clear( sizeof *c );
 675     int rc = do_proc_packets( c, a );
 676     m_free( c );
 677     return rc;
 678 }
 679
 680 int
 681 proc_signature_packets( IOBUF a, STRLIST signedfiles, const char *sigfilename )
 682 {
 683     CTX c = m_alloc_clear( sizeof *c );
 684     int rc;
 685     c->sigs_only = 1;
 686     c->signed_data = signedfiles;
 687     c->sigfilename = sigfilename;
 688     rc = do_proc_packets( c, a );
 689     m_free( c );
 690     return rc;
 691 }
 692
 693 int
 694 proc_encryption_packets( IOBUF a )
 695 {
 696     CTX c = m_alloc_clear( sizeof *c );
 697     int rc;
 698     c->encrypt_only = 1;
 699     rc = do_proc_packets( c, a );
 700     m_free( c );
 701     return rc;
 702 }
 703
 704
 705 int
 706 do_proc_packets( CTX c, IOBUF a )
 707 {
 708     PACKET *pkt = m_alloc( sizeof *pkt );
 709     int rc=0;
 710     int newpkt;
 711
 712     c->iobuf = a;
 713     init_packet(pkt);
 714     while( (rc=parse_packet(a, pkt)) != -1 ) {
 715         /* cleanup if we have an illegal data structure */
 716         if( c->dek && pkt->pkttype != PKT_ENCRYPTED ) {
 717             /* FIXME: do we need to ave it in case we have no secret
 718              * key for one of the next reciepents- we should check it
 719              * here. */
 720             m_free(c->dek); c->dek = NULL; /* burn it */
 721         }
 722
 723         if( rc ) {
 724             free_packet(pkt);
 725             if( rc == G10ERR_INVALID_PACKET )
 726                 break;
 727             continue;
 728         }
 729         newpkt = -1;
 730         if( opt.list_packets ) {
 731             switch( pkt->pkttype ) {
 732               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
 733               case PKT_ENCRYPTED:   proc_encrypted( c, pkt ); break;
 734               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
 735               default: newpkt = 0; break;
 736             }
 737         }
 738         else if( c->sigs_only ) {
 739             switch( pkt->pkttype ) {
 740               case PKT_PUBLIC_KEY:
 741               case PKT_SECRET_KEY:
 742               case PKT_USER_ID:
 743               case PKT_SYMKEY_ENC:
 744               case PKT_PUBKEY_ENC:
 745               case PKT_ENCRYPTED:
 746                 rc = G10ERR_UNEXPECTED;
 747                 goto leave;
 748               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
 749               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
 750               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
 751               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
 752               default: newpkt = 0; break;
 753             }
 754         }
 755         else if( c->encrypt_only ) {
 756             switch( pkt->pkttype ) {
 757               case PKT_PUBLIC_KEY:
 758               case PKT_SECRET_KEY:
 759               case PKT_USER_ID:
 760                 rc = G10ERR_UNEXPECTED;
 761                 goto leave;
 762               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
 763               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
 764               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
 765               case PKT_ENCRYPTED:   proc_encrypted( c, pkt ); break;
 766               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
 767               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
 768               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
 769               default: newpkt = 0; break;
 770             }
 771         }
 772         else {
 773             switch( pkt->pkttype ) {
 774               case PKT_PUBLIC_KEY:
 775               case PKT_SECRET_KEY:
 776                 release_list( c );
 777                 c->list = new_kbnode( pkt );
 778                 newpkt = 1;
 779                 break;
 780               case PKT_PUBLIC_SUBKEY:
 781               case PKT_SECRET_SUBKEY:
 782                 newpkt = add_subkey( c, pkt );
 783                 break;
 784               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
 785               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
 786               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
 787               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
 788               case PKT_ENCRYPTED:   proc_encrypted( c, pkt ); break;
 789               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
 790               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
 791               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
 792               default: newpkt = 0; break;
 793             }
 794         }
 795         if( pkt->pkttype != PKT_SIGNATURE )
 796             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
 797
 798         if( newpkt == -1 )
 799             ;
 800         else if( newpkt ) {
 801             pkt = m_alloc( sizeof *pkt );
 802             init_packet(pkt);
 803         }
 804         else
 805             free_packet(pkt);
 806     }
 807     rc = 0;
 808
 809   leave:
 810     release_list( c );
 811     m_free(c->dek);
 812     free_packet( pkt );
 813     m_free( pkt );
 814     free_md_filter_context( &c->mfx );
 815     return rc;
 816 }
 817
 818
 819 static void
 820 print_keyid( FILE *fp, u32 *keyid )
 821 {
 822     size_t n;
 823     char *p = get_user_id( keyid, &n );
 824     print_string( fp, p, n, opt.with_colons );
 825     m_free(p);
 826 }
 827
 828
 829
 830 static int
 831 check_sig_and_print( CTX c, KBNODE node )
 832 {
 833     PKT_signature *sig = node->pkt->pkt.signature;
 834     const char *astr, *tstr;
 835     int rc;
 836
 837     if( opt.skip_verify ) {
 838         log_info("signature verification suppressed\n");
 839         return 0;
 840     }
 841
 842     tstr = asctimestamp(sig->timestamp);
 843     astr = pubkey_algo_to_string( sig->pubkey_algo );
 844     log_info(_("Signature made %.*s using %s key ID %08lX\n"),
 845             (int)strlen(tstr)-1, tstr, astr? astr: "?", (ulong)sig->keyid[1] );
 846
 847     rc = do_check_sig(c, node, NULL );
 848     if( !rc || rc == G10ERR_BAD_SIGN ) {
 849         write_status( rc? STATUS_BADSIG : STATUS_GOODSIG );
 850         log_info(rc? _("BAD signature from \"")
 851                    : _("Good signature from \""));
 852         print_keyid( stderr, sig->keyid );
 853         putc('\"', stderr);
 854         putc('\n', stderr);
 855         if( !rc )
 856             rc = check_signatures_trust( sig );
 857         if( opt.batch && rc )
 858             g10_exit(1);
 859     }
 860     else {
 861         write_status( STATUS_ERRSIG );
 862         log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
 863     }
 864     return rc;
 865 }
 866
 867
 868 /****************
 869  * Process the tree which starts at node
 870  */
 871 static void
 872 proc_tree( CTX c, KBNODE node )
 873 {
 874     KBNODE n1;
 875     int rc;
 876
 877     if( opt.list_packets )
 878         return;
 879
 880     c->local_id = 0;
 881     c->trustletter = ' ';
 882     if( node->pkt->pkttype == PKT_PUBLIC_KEY
 883         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
 884         list_node( c, node );
 885     else if( node->pkt->pkttype == PKT_SECRET_KEY )
 886         list_node( c, node );
 887     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
 888         /* check all signatures */
 889         if( !c->have_data ) {
 890             free_md_filter_context( &c->mfx );
 891             /* prepare to create all requested message digests */
 892             c->mfx.md = md_open(0, 0);
 893             /* fixme: why looking for the signature packet and not 1passpacket*/
 894             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
 895                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
 896             }
 897             /* ask for file and hash it */
 898             if( c->sigs_only )
 899                 rc = hash_datafiles( c->mfx.md, c->signed_data, c->sigfilename,
 900                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
 901             else
 902                 rc = ask_for_detached_datafile( &c->mfx,
 903                                             iobuf_get_fname(c->iobuf));
 904             if( rc ) {
 905                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
 906                 return;
 907             }
 908         }
 909
 910         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
 911             check_sig_and_print( c, n1 );
 912     }
 913     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
 914         PKT_signature *sig = node->pkt->pkt.signature;
 915
 916         if( !c->have_data ) {
 917             free_md_filter_context( &c->mfx );
 918             c->mfx.md = md_open(sig->digest_algo, 0);
 919             if( c->sigs_only )
 920                 rc = hash_datafiles( c->mfx.md, c->signed_data, c->sigfilename,
 921                                      sig->sig_class == 0x01 );
 922             else
 923                 rc = ask_for_detached_datafile( &c->mfx,
 924                                             iobuf_get_fname(c->iobuf));
 925             if( rc ) {
 926                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
 927                 return;
 928             }
 929         }
 930         else
 931             log_info("old style signature\n");
 932
 933         check_sig_and_print( c, node );
 934     }
 935     else
 936         log_error("proc_tree: invalid root packet\n");
 937
 938 }
 939
 940
 941