dodecode.c

vc环境下的pgp源码

                                LANG("Good signature from user \"%s\".\n"),
                                useridstr );

                    } else {
                        fprintf(  filebPtr->pgpout, LANG(
"WARNING: Bad signature, doesn't match file contents!\n"));
                        fprintf(  filebPtr->pgpout, LANG(
"\nBad signature from user \"%s\".\n"), useridstr );

                    }
                } else {
                    char kstr[kPGPMaxKeyIDStringSize];

                    /* if we don't have the public key, we cant check
                       the signature.*/

                    err = pgpGetKeyIDStringCompat(
                            &event->data.signatureData.signingKeyID, TRUE,
                            envbPtr->compatible, kstr );

                    sprintf( useridstr, LANG("(KeyID: %s)"), kstr);

                    fprintf( filebPtr->pgpout,
                            LANG("signature not checked.\n"));

                }

                fprintf( filebPtr->pgpout, LANG("Signature made %s\n"),
                        ctdate(&(event->data.signatureData.creationTime)) );


                if( event->data.signatureData.keyRevoked) {
                    fprintf( filebPtr->pgpout,
                            LANG("signing key is revoked.\n"));
                }
                if( event->data.signatureData.keyDisabled) {
                    fprintf( filebPtr->pgpout,
                            LANG("signing key is disabled.\n"));
                }
                if( event->data.signatureData.keyExpired) {
                    fprintf( filebPtr->pgpout,
                            LANG("signing key is expired.\n"));
                }
                if( !event->data.signatureData.keyMeetsValidityThreshold ) {
                    fprintf( filebPtr->pgpout,
                            LANG("key does not meet validity threshold.\n"));
                }
                switch( event->data.signatureData.keyValidity ) {
                    case kPGPValidity_Unknown:
                    case kPGPValidity_Invalid:
                    case kPGPValidity_Marginal:

                        fprintf( filebPtr->pgpout, LANG("\n\
WARNING:  Because this public key is not certified with a trusted\n\
signature, it is not known with high confidence that this public key\n\
actually belongs to: \"%s\".\n"), useridstr);

                        break;
                    case kPGPValidity_Complete:
                    default:
                        break;
                }
#if 0
                /* XXX the sdk doesn't export this functionality.

                   When the -b field is present we want to dump the
                   signature to a separate file on decode events.
                   This requires that we know the original name of the
                   input file so we can append a .sig to it as the sig
                   output.  We always output in binary - no ascii output
                   was present in 262 for signatures.  - Anselm Jan 25 98

                   if( -b flag ) {
                       err = PGPNewFileSpecFromFullPath(context,
                            mainbPtr->plainfilename, &plainFileSpec);

                    pgpFixBeforeShip("encode the signature");

                    event->data.signatureData.signature
                    pgpFixBeforeShip("and output to a .sig file");
                    }
                 */
#endif
            }
            err = kPGPError_NoErr;
            break;

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

                fprintf( filebPtr->pgpout, LANG("symmetric cipher used: "));
                switch( event->data.decryptionData.cipherAlgorithm ) {
                    case kPGPCipherAlgorithm_IDEA:
                        fprintf( filebPtr->pgpout, "IDEA\n");
                        break;
                    case kPGPCipherAlgorithm_3DES:
                        fprintf( filebPtr->pgpout, "3DES\n");
                        break;
                    case kPGPCipherAlgorithm_CAST5:
                        fprintf( filebPtr->pgpout, "CAST5\n");
                        break;
                    default:
                        fprintf( filebPtr->pgpout, LANG("unknown\n"));
                        break;
                }
            }
            err = kPGPError_NoErr;
            break;

        case kPGPEvent_OutputEvent:
            if( verbose )
            {
                fprintf( filebPtr->pgpout,
                        LANG("event %d: Output options\n"), event->type);
                fprintf( filebPtr->pgpout, LANG("typecode: %04x\n"),
                        event->data.outputData.messageType );

                if( event->data.outputData.forYourEyesOnly ){
                    fprintf( filebPtr->pgpout, LANG("for your eyes only\n"));
                } else
                    fprintf( filebPtr->pgpout, LANG("suggested name: %s\n"),
                            event->data.outputData.suggestedName );
            }

            if( event->data.outputData.forYourEyesOnly ){

                fprintf(filebPtr->pgpout, LANG(
"\n\nThis message is marked \"For your eyes only\".  Display now (Y/n)? "));

                if (!batchmode && getyesno(filebPtr, 'y', 0)) {

                    /*
                       If the buffer is too small, tough luck. Sorry. Try
                       recompiling PGP with a larger fyeo-buffer. See
                       HUGE_MORE_BUFFER in config.h
                     */
                    pgpAssert( mainbPtr->fyeoBuffer == NULL );

                    err = PGPAddJobOptions( job,
                            PGPOAllocatedOutputBuffer( context,
                                    (void **)&mainbPtr->fyeoBuffer,
                                    kMaxMoreBufferLength,
                                    &mainbPtr->fyeoBufferLength ),
                            PGPOAppendOutput(context, TRUE),
                            PGPOLastOption( context ) );
                    pgpAssertNoErr(err);

                    /*
                       So this will actually get displayed when the
                       decode is finished.  he knows to display it if
                       the fyeo buffer is not NULL.
                     */

                } else {
                    err = PGPAddJobOptions( job,
                            PGPODiscardOutput( context, TRUE),
                            PGPOLastOption( context ) );
                    pgpAssertNoErr(err);
                }

            } else {
                int errorLvl;
                char *decodefilename = tempFile( filebPtr, TMP_WIPE,
                        &errorLvl );
                pgpAssertAddrValid( decodefilename, char );

                /* check to see if need to restore the original file name,
                   the memory allocated here is freed in args.c */
                if(mainbPtr->argsbPtr->preserveFileName)
                {
                    PGPUInt16   len = strlen(event->data.outputData.suggestedName) + 1;
                    mainbPtr->argsbPtr->outputFileName = malloc(sizeof(char) * len);
                    if(mainbPtr->argsbPtr->outputFileName)
                        strcpy(mainbPtr->argsbPtr->outputFileName,
                                event->data.outputData.suggestedName);
                    else
                    {
                        err = kPGPError_OutOfMemory;
                        break;
                    }
                }

                if( decodefilename ) {
                    PGPError er2;
                    PGPFileSpecRef resultFileSpec = NULL;

                    err = PGPNewFileSpecFromFullPath(context,
                            decodefilename, &resultFileSpec);
                    pgpAssertNoErr(err);

                    err = PGPAddJobOptions( job,
                            PGPOOutputFile( context, resultFileSpec ),
                            PGPOLastOption( context ) );
                    pgpAssertNoErr(err);

                    er2 = PGPFreeFileSpec(resultFileSpec);
                    pgpAssertNoErr(er2);

                    er2 = pgpAppendToFileNameList(
                            mainbPtr->decodefilenames, decodefilename );

                    pgpAssertNoErr(er2);
                }
            }
            err = 0;
            break;

        case kPGPEvent_ErrorEvent:
            /* event->data.errorData.
               PGPError error;
               void     *errorArg;
             */
            if( verbose )
                fprintf( filebPtr->pgpout, LANG("event %d: error %d\n"),
                        event->type,event->data.errorData.error);
            if( event->data.errorData.error ) {
                err = PGPAddJobOptions( job,
                        PGPOAppendOutput(context, FALSE),
                        PGPOLastOption( context ) );
                pgpAssertNoErr(err);
            }
            
            if(errno == ENOSPC)
                fprintf(filebPtr->pgpout,
                        LANG("Error: No space left on device.\n"));

            err = 0;
            break;

        case kPGPEvent_WarningEvent:
            /* event->data.warningData.
               PGPError warning;
               void     *warningArg;
             */

            if( verbose )
                fprintf( filebPtr->pgpout, LANG("event %d: warning %d\n"),
                        event->type,event->data.warningData.warning);
            /*if( event->data.warningData.warning == kPGPError_KeyInvalid )*/
            err = 0;
            break;

        default:
            /* ignore the event...*/
            if( verbose )
                fprintf( filebPtr->pgpout, LANG("event %d: unknown\n"),
                        event->type);
            err = 0;
    }
    return err;
}


int pgpDoDecode(struct pgpmainBones *mainbPtr, char *workfilename,
        int *perrorLvl )
{
    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env;

    PGPFileSpecRef workFileSpec = NULL;
    PGPError err,er2;
    PGPInt32 pri;
    PGPKeySetRef ringSet;

    err = PGPNewFileSpecFromFullPath(context, workfilename, &workFileSpec);
    pgpAssertNoErr(err);

        /*
           in case there are keys in the input, open the keyrings
           mutable+create.
         */

    err = PGPOpenDefaultKeyRings( context,
            kPGPKeyRingOpenFlags_Mutable|kPGPKeyRingOpenFlags_Create,
            &ringSet );

    pgpAssertNoErr(err);

    /* should we add all the passphrases we know of to the job options??*/
    err = pgpRewindPassphrase( envbPtr->passwds );
    pgpAssertNoErr(err);

    mainbPtr->workingRingSet = ringSet;

    if (envbPtr->moreFlag) {
      /* -m option specified on cmdline */
 
        fprintf(filebPtr->pgpout, "moreflag");

        pgpAssert( mainbPtr->fyeoBuffer == NULL );

        err = PGPDecode( context,
            PGPOInputFile( context, workFileSpec ),
            PGPOKeySetRef( context, ringSet ),
            PGPOSendEventIfKeyFound( context, TRUE ),
            PGPOPassThroughIfUnrecognized( context, envbPtr->passThrough ),
            PGPOEventHandler( context, dechandler, (PGPUserValue) mainbPtr),
            PGPOAllocatedOutputBuffer( context,
                  (void **)&mainbPtr->fyeoBuffer,
                   kMaxMoreBufferLength,
                   &mainbPtr->fyeoBufferLength ),
            PGPOAppendOutput(context, TRUE),
            PGPOLastOption( context ) );
            pgpAssertNoErr(err);
    }
    else {

        err = PGPDecode( context,
            PGPOInputFile( context, workFileSpec ),
            PGPOKeySetRef( context, ringSet ),
            PGPOSendEventIfKeyFound( context, TRUE ),
            PGPOPassThroughIfUnrecognized( context, envbPtr->passThrough ),
            PGPOEventHandler( context, dechandler, (PGPUserValue) mainbPtr),
            PGPOLastOption( context ) );
    }
    if( IsPGPError(err) )
        pgpShowError( filebPtr, err, 0,0);
    else
    if ( mainbPtr->fyeoBuffer ) {
        err = moreBuffer( filebPtr, mainbPtr->fyeoBuffer,
                mainbPtr->fyeoBufferLength );
        PGPFreeData(mainbPtr->fyeoBuffer);
        mainbPtr->fyeoBuffer=NULL;
    }

    er2 = PGPFreeKeySet( ringSet );
    pgpAssertNoErr(er2);
    mainbPtr->workingRingSet = NULL;

    er2 = PGPFreeFileSpec(workFileSpec);
    pgpAssertNoErr(er2);

    if (pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &er2 ) &&
            !mainbPtr->signatureChecked)

        *perrorLvl=1; /* alternate success, file did not have sig. */
    else
        *perrorLvl=EXIT_OK;
    return err;
}