doencode.c

PGP—Pretty Good Privacy

    err = pgpRewindPassphrase( envbPtr->passwds );
    pgpAssertNoErr(err);

    /* set up mykey*/
    if( argsbPtr->signFlag) {
        mainbPtr->workingRingSet=keyringset;
        err = pgpGetMySigningKey( mainbPtr, &mykey );

        if( IsPGPError(err) ) {
            pgpShowError(filebPtr, err, 0,0); /*__FILE__,__LINE__);*/
            goto done;
        }

        err = pgpGetValidPassphrase( mainbPtr, mykey, &signPassphrase,
                &signMine );
    }

    /* should we add all the passphrases we know of to the job options?*/
    /* Try any passphrases already stored first,
           then try each one until we get a hit. once they're used up, */
    pgpNextPassphrase( envbPtr->passwds, &passphrase );

    if(passphrase == NULL) {
        mine=TRUE;

        if (!pgpenvGetInt( env, PGPENV_NOOUT, &pri, &err ))
            fprintf(filebPtr->pgpout,
            LANG("\nYou need a pass phrase to encrypt the file. "));

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

        if IsntPGPError(err) {
            err = pgpAppendToPassphraseList( envbPtr->passwds, passphrase );
            pgpAssertNoErr(err);
        }
    }

    if( IsntPGPError( err ) ) {

          if( pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err) )
          {
              fprintf( filebPtr->pgpout, LANG("armor out: %d\n"), armorout );
              fprintf( filebPtr->pgpout, LANG("sign flag: %d\n"),
                      argsbPtr->signFlag  );
              if(argsbPtr->signFlag)
                  fprintf( filebPtr->pgpout, LANG("clearsign: %d\n"),
                          clearsig );
              fprintf( filebPtr->pgpout, LANG("strip sig: %d\n"),
                      argsbPtr->stripSigFlag  );
              fprintf( filebPtr->pgpout, LANG("textmode : %d\n"), textmode );
              fprintf( filebPtr->pgpout, LANG("compressn: %d\n"),
                      attemptCompression);
              fprintf( filebPtr->pgpout, LANG("youreyeso: %d\n"),
                      envbPtr->moreFlag );
              fprintf( filebPtr->pgpout, LANG("batchMode: %d\n"),
                      batchMode );

          }



          /* encrypt the file... */
          err = PGPEncode( context,
                  PGPOInputFile( context, infilespec ),
                  PGPOOutputFile( context, outfilespec ),

                  argsbPtr->signFlag ? PGPOSignWithKey( context, mykey,
                      PGPOPassphrase( context, signPassphrase ),
                      PGPOLastOption( context )  ) : PGPONullOption(
                      context ),
                  argsbPtr->signFlag ? PGPOClearSign( context, clearsig )
                  : PGPONullOption( context ),

                  argsbPtr->stripSigFlag ? PGPODetachedSig( context,
                          PGPOLastOption( context ) ) : PGPONullOption(
                                  context ),

                  PGPODataIsASCII( context, textmode ),
                  PGPOCompression( context, attemptCompression),
                  PGPOForYourEyesOnly( context, envbPtr->moreFlag ),
                  PGPOAskUserForEntropy( context, !batchMode ),
                  PGPOArmorOutput(context, armorout ),
                  PGPOConventionalEncrypt( context, PGPOPassphrase(
                          context, passphrase ), PGPOLastOption( context )),
                  /* warn below validity,*/
                  PGPOEventHandler( context, enchandler, (PGPUserValue)
                          mainbPtr),

                  PGPOLastOption( context ) );

          if (mine) {
              er2 = PGPFreeData( passphrase );
              pgpRemoveFromPointerList( mainbPtr->leaks, passphrase );
              pgpAssertNoErr(er2);
          }

          if (signMine) {
              er2 = PGPFreeData( signPassphrase );
              pgpRemoveFromPointerList( mainbPtr->leaks, signPassphrase );
              pgpAssertNoErr(er2);
          }
    }

    if( !compatible && IsPGPError( err ) )
        pgpShowError( filebPtr, err,__FILE__,__LINE__);

done:

    if( keyringset ) {
        PGPFreeKeySet( keyringset );
        mainbPtr->workingRingSet=NULL;
    }

    er2 = PGPFreeFileSpec(infilespec);
    pgpAssertNoErr(er2);
    er2 = PGPFreeFileSpec(outfilespec);
    pgpAssertNoErr(er2);

    return err;
}

/* Armorout or compress the file without encrypting. */
int encodeOnly(struct pgpmainBones *mainbPtr, char *infile, char *outfile,
        PGPBoolean attemptCompression)
{

    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpargsBones *argsbPtr = mainbPtr->argsbPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    PGPEnv *env = pgpContextGetEnvironment( context );

    PGPFileSpecRef infilespec = NULL, outfilespec = NULL;
    PGPError err,er2;
    PGPInt32 pri;

    PGPBoolean textmode = pgpenvGetInt( env, PGPENV_TEXTMODE, &pri, &er2);
    PGPBoolean batchMode = pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &er2 );
    PGPBoolean armorout = pgpenvGetInt( env, PGPENV_ARMOR, &pri, &err);

    PGPBoolean compatible = envbPtr->compatible;

    PGPBoolean clearsig;

    clearsig = pgpenvGetInt( env, PGPENV_CLEARSIG, &pri, &er2);
    /* prevent certain feature interactions with clearsig.*/
    if( pri <= PGPENV_PRI_PUBDEFAULT )
        clearsig = FALSE;

    err = PGPNewFileSpecFromFullPath(context, infile, &infilespec);
    pgpAssertNoErr(err);
    err = PGPNewFileSpecFromFullPath(context, outfile, &outfilespec);
    pgpAssertNoErr(err);


    if( IsntPGPError( err ) ) {

          if( pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err) )
          {
              fprintf( filebPtr->pgpout, LANG("armor out: %d\n"), armorout );
              fprintf( filebPtr->pgpout, LANG("sign flag: %d\n"),
                      argsbPtr->signFlag  );
              if(argsbPtr->signFlag)
                  fprintf( filebPtr->pgpout, LANG("clearsign: %d\n"),
                  clearsig );

              fprintf( filebPtr->pgpout, LANG("strip sig: %d\n"),
                      argsbPtr->stripSigFlag  );
              fprintf( filebPtr->pgpout, LANG("textmode : %d\n"), textmode );
              fprintf( filebPtr->pgpout, LANG("compressn: %d\n"),
                      attemptCompression);
              fprintf( filebPtr->pgpout, LANG("youreyeso: %d\n"),
                      envbPtr->moreFlag );
              fprintf( filebPtr->pgpout, LANG("batchMode: %d\n"),
                      batchMode );
          }

          /* encode the file... */
          err = PGPEncode( context,
                  PGPOInputFile( context, infilespec ),
                  PGPOOutputFile( context, outfilespec ),
                  textmode ? PGPODataIsASCII( context, textmode ) :
                  PGPONullOption( context ),

                  attemptCompression ? PGPOCompression( context,
                          attemptCompression) : PGPONullOption( context ),

                  armorout ? PGPOArmorOutput( context, armorout ) :
                  PGPONullOption( context ),

                  PGPOEventHandler( context, enchandler, (PGPUserValue)
                          mainbPtr),

                  PGPOLastOption( context ) );

    }

    if( !compatible && IsPGPError( err ) )
        pgpShowError( filebPtr, err,__FILE__,__LINE__);


    er2 = PGPFreeFileSpec(infilespec);
    pgpAssertNoErr(er2);
    er2 = PGPFreeFileSpec(outfilespec);
    pgpAssertNoErr(er2);

    return err;

}   /* encodeOnly */



 /*
    Do everything, from encapsulation and signing to encryption and armoring.
  */

int pgpDoEncode(struct pgpmainBones *mainbPtr, char *workfilename,
        char **resultfilename, int *perrorLvl )
{
    struct pgpargsBones *argsbPtr=mainbPtr->argsbPtr;
    struct pgpfileBones *filebPtr=mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr=mainbPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env;
    PGPInt32 pri;
    PGPError err;
    char *tempf;
    int status;
    PGPBoolean attemptCompression;

    /* -- encapsulation ----------------------------------------------- */

    /*
     * See if mainbPtr->plainfilename looks like it might be incompressible,
     * by examining its contents for compression headers for
     * commonly-used compressed file formats like PKZIP, etc.
     * Remember this information for later, when we are deciding
     * whether to attempt compression before encryption.
     *
     * Naturally, don't bother if we are making a separate signature or
     * clear-signed message.  Also, don't bother trying to compress a
     * PGP message, as it's probably already compressed.
     */
    attemptCompression = pgpenvGetInt( env, PGPENV_COMPRESS, &pri, &err )
        && !mainbPtr->separateSignature && envbPtr->makeRandom == 0 &&
        fileCompressible(mainbPtr->plainfilename);

    /* -- signing ----------------------------------------------------- */

    if (argsbPtr->signFlag) {
        if (!envbPtr->filterMode && !pgpenvGetInt( env, PGPENV_NOOUT,
                &pri, &err ))
            fprintf(filebPtr->pgpout,
                    LANG("\nA secret key is required to make a signature. "));
    }


    /* first create a tempfile to hold the encrypted or signed output. if
       armor or output-stdout then the tempfile will be wiped upon
       exit(). */

    if (pgpenvGetInt( env, PGPENV_ARMOR, &pri, &err ) ||
            mainbPtr->outputStdout) {

        if((tempf = tempFile( filebPtr, TMP_WIPE | TMP_TMPDIR, perrorLvl))
                == NULL && *perrorLvl != 0)
            return -1;
    } else {
        if((tempf = tempFile( filebPtr, TMP_WIPE, perrorLvl)) == NULL &&
                *perrorLvl != 0)
            return -1;
    }

    /* -- signing only ---------------------------------------------- */
    if (argsbPtr->signFlag && !argsbPtr->encryptFlag) {
        status = signfile(mainbPtr, mainbPtr->separateSignature,
                workfilename, tempf, attemptCompression );

        if (status < 0) {
            fprintf(filebPtr->pgpout, LANG("\007Signature error\n"));
            *perrorLvl = SIGNATURE_ERROR;
            userError(filebPtr,perrorLvl);
            return -1;
        }

        *resultfilename = tempf;
        return 0;
    }

    /* -- encryption --------------------------------------------------- */
    if (argsbPtr->encryptFlag) {
        /* conventional or public-key encrypt?
           if public-key encrypt, get the recipients first. */

        if (!argsbPtr->conventionalFlag) {
            struct RecipList reclist;
            if((err = pgpBuildRecipList(mainbPtr, &reclist)) != 0) {
                *perrorLvl = OUT_OF_MEM;
                return -1;
            }
            status = encryptFile(mainbPtr, (const char **)reclist.recips,
                    workfilename, tempf, attemptCompression);

            pgpFreeRecipList( &reclist );

        } else {
            status = conventionalEncryptFile(mainbPtr, workfilename,
                    tempf, attemptCompression);

        }

        *resultfilename = tempf;

        if (status < 0) {
            fprintf(filebPtr->pgpout, LANG("\007Encryption error\n"));
            *perrorLvl = (argsbPtr->conventionalFlag ? ENCR_ERROR :
                    PK_ENCR_ERROR);

            userError(filebPtr,perrorLvl);
            return -1;
        }
    } else if (attemptCompression && !mainbPtr->separateSignature) {
        /*
         * PGP used to be parsimonious about compressin; originally, it only
         * did it for files that were being encrypted (to reduce the
         * redundancy in the plaintext), but it should really do it for
         * anything where it's not a bad idea.
         */
        if (pgpenvGetInt( env, PGPENV_ARMOR, &pri, &err ) ||
                mainbPtr->outputStdout) {
            if((tempf = tempFile( filebPtr, TMP_WIPE | TMP_TMPDIR,
                    perrorLvl))==NULL && *perrorLvl != 0)
                return -1;
        } else {
            if((tempf = tempFile( filebPtr, TMP_WIPE, perrorLvl))==NULL &&
                    *perrorLvl != 0)
                return -1;
        }
        status = encodeOnly( mainbPtr, workfilename, tempf,
                attemptCompression );

        *resultfilename = tempf;

        if (status < 0) {
            fprintf(filebPtr->pgpout, LANG("\007Encryption error\n"));
            *perrorLvl = (argsbPtr->conventionalFlag ? ENCR_ERROR :
                    PK_ENCR_ERROR);
            userError(filebPtr,perrorLvl);
            return -1;
        }

    }
    return 0;
}