dodecode.c

vc环境下的pgp源码

/*____________________________________________________________________________
    dodeocde.c

    Copyright(C) 1998,1999 Network Associates, Inc.
    All rights reserved.

	PGP 6.5 Command Line 

    uses the PGP SDK to decode messages.

    $Id: dodecode.c,v 1.14 1999/05/12 21:01:03 sluu Exp $
____________________________________________________________________________*/

#include <stdio.h>
#include <assert.h>
#include <errno.h>

#include "pgpBase.h"
#include "pgpKeys.h"
#include "pgpErrors.h"
#include "pgpUserInterface.h"
#include "pgpUtilities.h"

#include "config.h"
#include "usuals.h"
#include "language.h"
#include "pgp.h"
#include "globals.h"
#include "fileio.h"
#include "exitcodes.h"
#include "prototypes.h"


 /* input: is a key iter positioned at a particular key.
    returns: the number of userids associated with the key.
    side-effects: the positioned userid is reuturned undefined.
  */

PGPError pgpCountKeyUserIDs( PGPKeyIterRef keyiter, PGPUInt32 *numuserids )
{
    PGPError err;
    PGPUserIDRef userid;
    *numuserids = 0;

    /* list all userids associated with the key. */
    err = PGPKeyIterRewindUserID( keyiter );
    if(err)
        return err;

    err = PGPKeyIterNextUserID( keyiter, &userid);
    pgpAssertNoErr(err);
    if( userid ) {
        while( userid ) {
            (*numuserids)++;
            err = PGPKeyIterNextUserID( keyiter, &userid);
        }
    }
    return kPGPError_NoErr;
}

PGPError dechandler(PGPContextRef context, struct PGPEvent *event,
        PGPUserValue userValue)
{
    struct pgpmainBones *mainbPtr = (struct pgpmainBones *)userValue;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env;
    PGPJobRef job = event->job;

    PGPError err;
    PGPInt32 pri;
    PGPInt32 verbose = pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err );
    PGPBoolean quietmode = pgpenvGetInt( env, PGPENV_NOOUT, &pri, &err);
    PGPInt32 batchmode = pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &err );

    /* get the event type*/
    switch ( event->type ) {
        case kPGPEvent_FinalEvent:
            if( verbose )
                fprintf( filebPtr->pgpout, LANG("event %d: final\n"),
                        event->type);

                        err = kPGPError_NoErr;

            /* tear down anything we need to here*/

            /* finish adding any keys*/
            addToWorkingRingSetFinish( mainbPtr );
            break;

        case kPGPEvent_InitialEvent:
            if( verbose )
                fprintf( filebPtr->pgpout, LANG("\nevent %d: initial\n"),
                        event->type);
            /* set up whatever we need to here*/
            err = kPGPError_NoErr;
            break;

        case kPGPEvent_BeginLexEvent:
            if( verbose )
                fprintf( filebPtr->pgpout, LANG("event %d: BeginLex\n"),
                        event->type);
            err = kPGPError_NoErr;
            break;

        case kPGPEvent_EndLexEvent:
            if( verbose )
                fprintf( filebPtr->pgpout, LANG("event %d: EndLex\n"),
                        event->type);
            err = kPGPError_NoErr;
            break;

        case kPGPEvent_AnalyzeEvent:
            if (quietmode) {
                err = kPGPError_NoErr;
                break;
            }

            if( verbose )
                fprintf( filebPtr->pgpout, LANG("event %d: Analyze\n"),
                        event->type);

            switch ( event->data.analyzeData.sectionType ) {
                case kPGPAnalyze_Encrypted:
                    fprintf( filebPtr->pgpout, LANG("File is encrypted.  "));
                    break;
                case kPGPAnalyze_Signed:
                    fprintf( filebPtr->pgpout, LANG("File is signed.  "));
                    break;
                case kPGPAnalyze_DetachedSignature:
                    fprintf( filebPtr->pgpout, LANG(
                            "File '%s' has signature, but with no text.\n"),
                            mainbPtr->plainfilename);

                    break;
                case kPGPAnalyze_Key:
                    /*fprintf( filebPtr->pgpout,
                      LANG( "File '%s' contains keys.\n"),
                      mainbPtr->plainfilename );*/

                    break;
                case kPGPAnalyze_Unknown:
                default:
                    fprintf( filebPtr->pgpout,
                            LANG("Unable to analyze event.\n"));

                    break;
            }
            err = kPGPError_NoErr;
            break;

        case kPGPEvent_RecipientsEvent:
            {
                /* event->data.recipientsData.
                   PGPKeySetRef     recipientSet;
                   PGPUInt32        conventionalPassphraseCount;
                   PGPUInt32        keyCount;
                   PGPKeyID const * keyIDArray;
                 */
                PGPKeySetRef keyset =
                    event->data.recipientsData.recipientSet;

                PGPKeyRef key = NULL;
                PGPKeyListRef keylist = NULL;
                PGPKeyIterRef keyiter = NULL;

                if( verbose )
                    fprintf( filebPtr->pgpout,
                            LANG("event %d: Recipients\n"),
                            event->type);

                err = kPGPError_NoErr;
                if( event->data.recipientsData.conventionalPassphraseCount
                        < 1)
                {
                    if (!quietmode) {
                        fprintf( filebPtr->pgpout,
                            LANG("Secret key is required to read it.\n"));
                    }
                    err = PGPOrderKeySet( keyset, kPGPAnyOrdering,
                            &keylist );
                    pgpAssertNoErr(err);
                    err = PGPNewKeyIter( keylist, &keyiter );
                    pgpAssertNoErr(err);
                    err = PGPKeyIterRewindUserID( keyiter );
                    pgpAssertNoErr(err);
                    err = PGPKeyIterNext( keyiter, &key);

                    if ( IsPGPError(err) ) {
                        err = kPGPError_NoDecryptionKeyFound;
                        fprintf(filebPtr->pgpout,
LANG("You do not have the secret key needed to decrypt this file.\n"));
                    }
                    else {
                        while( key != NULL )
                        {
                            PGPBoolean issecret;
                            err = PGPGetKeyBoolean( key, kPGPKeyPropIsSecret,
                                &issecret);
                            pgpAssertNoErr(err);

                            if (issecret || verbose) {

                                if (issecret && quietmode) {
                                    err = pgpShowKeyUserID(filebPtr, key);
                                    pgpAssertNoErr(err);
                                }
                                else {
                                    err = pgpShowKeyBrief(filebPtr, key);
                                    pgpAssertNoErr(err);
                                }
                            }
                            err = PGPKeyIterNext( keyiter, &key);
                            /*if err, there are no more*/
                        }
                    }
                    if(keyiter)
                        PGPFreeKeyIter(keyiter);
                    if(keylist)
                        PGPFreeKeyList(keylist);
                    if(err == kPGPError_EndOfIteration)
                        err = kPGPError_NoErr;
                }
            }
            break;

        case kPGPEvent_PassphraseEvent:
            {
                PGPBoolean mine=FALSE;
                char *passphrase;

                if( verbose )
                    fprintf( filebPtr->pgpout,
                            LANG("event %d: Passphrase\n"), event->type);

                /* when this event occurs, try any passphrases already
                   stored first, then try each one until we get a
                   hit. once they're used up, ask the user directly. */

                err = pgpNextPassphrase( envbPtr->passwds, &passphrase );
                if( err == kPGPError_EndOfIteration )
                    err = kPGPError_MissingPassphrase;

                if(!batchmode && passphrase == NULL) {
                    mine=TRUE;

                    if( event->data.passphraseData.fConventional ) {
                        fprintf( filebPtr->pgpout, LANG(
"You need a pass phrase to decrypt this file.\n") );
                    } else {
                        fprintf( filebPtr->pgpout, LANG(
"You need a pass phrase to unlock your secret key.\n") );
                    }

                    err = pgpPassphraseDialogCmdline( mainbPtr, FALSE,
                            NULL, &passphrase);

                }
                if( IsntPGPError(err)) {
                    err = PGPAddJobOptions( job,
                            PGPOPassphrase( context, passphrase ),
                            PGPOLastOption( context ) );
                    pgpAssertNoErr(err);
                }
                if(mine) {
                    PGPFreeData( passphrase );
                    pgpRemoveFromPointerList( mainbPtr->leaks, passphrase );
                }
            }
            break;

        case kPGPEvent_KeyFoundEvent:
            {
                if(verbose) {
                    fprintf( filebPtr->pgpout,
                            LANG("\nevent %d: key found\n"),
                            event->type);

                    fprintf( filebPtr->pgpout, LANG("%08lx\n"),
                            event->data.keyFoundData.keySet );

                }
                addToWorkingRingSet( mainbPtr,
                        event->data.keyFoundData.keySet );

            }
            break;

        case kPGPEvent_DetachedSignatureEvent:
            {
                PGPFileSpecRef plainFileSpec;
                if(verbose)
                    fprintf( filebPtr->pgpout,
                            LANG("\nevent %d: detached signature\n"),
                            event->type);

                /* if separate signature, need to communicate that*/
                /* to the output routines...*/
                mainbPtr->separateSignature = TRUE;

                dropExtension( filebPtr, mainbPtr->plainfilename );
                if (!quietmode) fprintf( filebPtr->pgpout,
                        LANG("Text is assumed to be in file '%s'.\n"),
                        mainbPtr->plainfilename);

                err = PGPNewFileSpecFromFullPath(context,
                        mainbPtr->plainfilename, &plainFileSpec);

                err = PGPAddJobOptions( job,
                        PGPODetachedSig( context,
                                PGPOInputFile(context, plainFileSpec),
                                PGPOLastOption( context )),
                        PGPOLastOption( context ) );
                pgpAssertNoErr(err);
                PGPFreeFileSpec(plainFileSpec);
            }
            break;

        case kPGPEvent_SignatureEvent:
            {
                PGPUserIDRef userid;
                char useridstr[ kPGPMaxUserIDSize ];
                PGPSize actual;
                /*PGPTime event->data.signatureData.creationTime;*/

                if( verbose )
                    fprintf( filebPtr->pgpout, LANG("event %d: Signature\n"),
                            event->type);

                if( event->data.signatureData.checked )
                {
                    /* so we have a Key.*/
                    pgpAssertAddrValid(
                            event->data.signatureData.signingKey, PGPKeyRef);

                    err = PGPGetPrimaryUserID(
                            event->data.signatureData.signingKey, &userid);

                    pgpAssertNoErr(err);

                    err = PGPGetUserIDStringBuffer( userid,
                            kPGPUserIDPropName, 256, useridstr, &actual );

                    pgpAssertNoErr(err);

                    if( event->data.signatureData.verified ) {
                        fprintf(  filebPtr->pgpout,