encrypt.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1997 Network Associates Inc. and affiliated companies.
	All rights reserved.

	$Id: encrypt.c,v 1.135 1999/04/13 17:29:54 wjb Exp $
____________________________________________________________________________*/
#include "precomp.h"

BOOL GetCommentLine(PGPContextRef context,
					char *comment,PGPSize size,PGPUInt32 *PrefAlg,
					PGPCipherAlgorithm *pAllowedAlgs, int *pNumAlgs)
{
	PGPPrefRef	ClientPrefRef=NULL;
	PGPPrefRef	AdminPrefRef=NULL;
	PGPError	err;
	BOOL RetVal;
	PGPMemoryMgrRef memMgr;

	memMgr=PGPGetContextMemoryMgr(context);

	RetVal=TRUE;

	*comment=0;
	*PrefAlg=kPGPCipherAlgorithm_CAST5;

#if PGP_BUSINESS_SECURITY
	err = PGPclOpenAdminPrefs (memMgr,&AdminPrefRef, PGPclIsAdminInstall());

	if (IsPGPError (err)) 
		return FALSE;	// error-out

	err=PGPGetPrefStringBuffer(AdminPrefRef,
	   kPGPPrefComments,
	   size,
	   comment);

	PGPclCloseAdminPrefs (AdminPrefRef, FALSE);
#endif	// PGP_BUSINESS_SECURITY

	err=PGPclOpenClientPrefs (memMgr,&ClientPrefRef);
	if(IsntPGPError(err))
	{
		PGPCipherAlgorithm *pData;
		PGPSize	dataLength;
		int i;

		PGPGetPrefNumber(ClientPrefRef,
			kPGPPrefPreferredAlgorithm, 
			PrefAlg);

		err = PGPGetPrefData(ClientPrefRef,
			kPGPPrefAllowedAlgorithmsList, 
			&dataLength, (void **) &pData);

		if (IsntPGPError(err))
		{
			*pNumAlgs = dataLength / sizeof(PGPCipherAlgorithm);
			for (i=0; i<*pNumAlgs; i++)
				pAllowedAlgs[i] = pData[i];

			PGPDisposePrefData(ClientPrefRef, (void *) pData);
		}
		else
			*pNumAlgs = 0;

		if(*comment==0)
		{
			PGPGetPrefStringBuffer(ClientPrefRef,
				kPGPPrefComment,
				size,
				comment);
		}
		PGPclCloseClientPrefs (ClientPrefRef, FALSE);
	}
	
	return RetVal;
}

PGPError GenericEncSign(MYSTATE *ms,
					PGPOptionListRef opts,
					char *OperationTarget)
{
	PGPError err;
	int UserCancel;
	PGPBoolean DataIsASCII;
	PGPUInt32 numKeys;
	PRECIPIENTDIALOGSTRUCT prds;
	PGPContextRef	context;
	char StrRes[500],szRDprompt[100],szPassTitle[100];
	PGPBoolean FYEO;

	err=kPGPError_NoErr;	
	
	context=ms->context;

	prds=ms->prds;

	// If this is first operation, put up recipient/sign dialog

	if(ms->numDone==0)
	{
		FreePhrases(ms);

		if(ms->Encrypt)
		{
			int RecipientReturn;

			LoadString (g_hinst, IDS_PGPKEYSELDLG, StrRes, sizeof(StrRes));
			strcpy(szRDprompt,ms->szAppName);
			strcat(szRDprompt,StrRes);

			prds->Version=CurrentPGPrecipVersion;
			prds->hwndParent=ms->hwndWorking;
			prds->szTitle=szRDprompt;
			prds->Context=ms->context;
			prds->tlsContext=ms->tlsContext;
			prds->OriginalKeySetRef=ms->KeySet;

			prds->dwDisableFlags|=PGPCL_DISABLE_FYEO;

			// FYEO only for clipboard or text files
			if((ms->Operation==MS_ENCRYPTCLIPBOARD) ||
				(FileHasThisExtension(OperationTarget,"txt")))
			{
				prds->dwDisableFlags&=(~PGPCL_DISABLE_FYEO);
			}

			if(!((ms->Operation==MS_ENCRYPTFILELIST)&&
				(ms->Encrypt)&&(!ms->Sign)))
				prds->dwDisableFlags|=PGPCL_DISABLE_SDA;

			RecipientReturn = PGPclRecipientDialog(prds);

			if(!RecipientReturn)
				return kPGPError_UserAbort;

			if(prds->dwOptions & PGPCL_SDA)
			{
				LoadString (g_hinst, IDS_ENTERPASSPHRASE, StrRes, sizeof(StrRes));
				strcpy(szPassTitle,ms->szAppName);
				strcat(szPassTitle,StrRes);

				LoadString (g_hinst, IDS_ENTERSDAPASS, StrRes, sizeof(StrRes));

				UserCancel = PGPclGetPhrase (context,
					ms->KeySet,
					ms->hwndWorking,
					StrRes,
					&(ms->ConvPassPhrase), 
					NULL,
					NULL, 
					0,
					NULL,
					NULL,
					PGPCL_ENCRYPTION,
					NULL,NULL,
					1,0,ms->tlsContext,NULL,szPassTitle);

				if(UserCancel)
					return kPGPError_UserAbort;
			}
			else if(prds->dwOptions & PGPCL_PASSONLY)
			{
				LoadString (g_hinst, IDS_ENTERPASSPHRASE, StrRes, sizeof(StrRes));
				strcpy(szPassTitle,ms->szAppName);
				strcat(szPassTitle,StrRes);

				LoadString (g_hinst, IDS_CONVPASSPROMPT, StrRes, sizeof(StrRes));

				UserCancel = PGPclGetPhrase (context,
					ms->KeySet,
					ms->hwndWorking,
					StrRes,
					&(ms->ConvPassPhrase), 
					NULL,
					NULL, 
					0,
					NULL,
					NULL,
					PGPCL_ENCRYPTION,
					NULL,NULL,
					1,0,ms->tlsContext,NULL,szPassTitle);

				if(UserCancel)
					return kPGPError_UserAbort;
			}

		}

		if(ms->Sign)
		{
			DWORD *lpOptions;
			PGPError err;

			LoadString (g_hinst, IDS_ENTERPASSPHRASE, StrRes, sizeof(StrRes));
			strcpy(szPassTitle,ms->szAppName);
			strcat(szPassTitle,StrRes);

			lpOptions=&(prds->dwOptions);

			if (ms->Encrypt || (ms->Operation==MS_ENCRYPTCLIPBOARD))
				lpOptions=0;

			LoadString (g_hinst, IDS_PASSPROMPTABOVEKEY, StrRes, sizeof(StrRes));

			err=PGPclGetCachedSigningPhrase (context,
				ms->tlsContext,
				ms->hwndWorking, 
				StrRes,
				FALSE, // ForceEntry
				&ms->PassPhrase,
				ms->KeySet,
				&(ms->SignKey),
				NULL,
				lpOptions,
				prds->dwFlags,
				&ms->PassKey,
				&ms->PassKeyLen,
				NULL,szPassTitle);
			
			if(err != kPGPError_NoErr)
			{
				PGPclEncDecErrorBox(ms->hwndWorking,err);
				return kPGPError_UserAbort; // UserCancel 
			}
		}
	} // END of first operation recipient/sign dialog stuff

	ms->fileName=OperationTarget;

	if(prds->dwOptions & PGPCL_SDA)
	{
		// Self Decryptor
		err=SDA(ms);

		// Inform loop to stop processing files, since we've done 
		// them all
		ms->bDoingSDA=TRUE;

		// Don't do anything else like file wiping etc...
		return err;
	}

	// if encrypting, throw in recipients
	if(ms->Encrypt)
	{
		if(prds->dwOptions & PGPCL_PASSONLY)
		{
			int ConvPassLen;

			ConvPassLen = strlen(ms->ConvPassPhrase);

			PGPAppendOptionList(opts,
				PGPOConventionalEncrypt(context, 
					PGPOPassphraseBuffer(context,ms->ConvPassPhrase,
						ConvPassLen),
						PGPOLastOption(context) ),
				PGPOCipherAlgorithm(context,ms->PrefAlg),
				PGPOLastOption(context) );
		}
		else
		{
			PGPAppendOptionList(opts,
				PGPOEncryptToKeySet(context,prds->SelectedKeySetRef),
				PGPOLastOption(context) );
		}
	}

	if(ms->Sign)  // If signing, throw in a passphrase and key
	{
		// Use passkey if available
		if(ms->PassKey)
		{
			PGPAppendOptionList(opts,
				PGPOSignWithKey(context,ms->SignKey,
					PGPOPasskeyBuffer(context,
						ms->PassKey,ms->PassKeyLen),
					PGPOLastOption(context) ),
				PGPOLastOption(context) );
		}
		else
		{
			PGPAppendOptionList(opts,
				PGPOSignWithKey(context,ms->SignKey,
					PGPOLastOption(context) ),
				PGPOLastOption(context) );
		}
	}

	if((prds->dwOptions & PGPCL_DETACHEDSIG) &&
		!(ms->Operation==MS_ENCRYPTCLIPBOARD) && 
		(ms->Sign) && !(ms->Encrypt))
	{
		PGPAppendOptionList(opts,
			PGPODetachedSig(context,
				PGPOLastOption(context)), 
			PGPOLastOption(context));
	}
	else
		prds->dwOptions&=(~PGPCL_DETACHEDSIG);

	DataIsASCII=(ms->Operation==MS_ENCRYPTCLIPBOARD);

	// If we have text out arguments....
	if(prds->dwOptions & PGPCL_ASCIIARMOR)
	{
		if((ms->Operation==MS_ENCRYPTCLIPBOARD) && 
			(ms->Sign) && !(ms->Encrypt) && 
			((prds->dwOptions & PGPCL_DETACHEDSIG)==0)) 
		{ // Clearsign!
			PGPAppendOptionList(opts,
				PGPOClearSign(context, TRUE),
				PGPOLastOption(context));
		}
		else if(!(ms->Operation==MS_ENCRYPTCLIPBOARD) && 
			(ms->Sign) && !(ms->Encrypt) && 
			((prds->dwOptions & PGPCL_DETACHEDSIG)==0)&&
		  FileHasThisExtension(OperationTarget,"txt")) 
		{ // Clearsign a .txt file
			DataIsASCII=TRUE; // Set to ASCII input

			PGPAppendOptionList(opts,
				PGPOClearSign(context, TRUE),
				PGPOLastOption(context));
		} 
		else // Just Ascii Armor*/
		{
			PGPAppendOptionList(opts,
				PGPOArmorOutput(context, TRUE),
				PGPOLastOption(context));
		}
	}

	if(*(ms->comment)!=0)
	{
		PGPAppendOptionList(opts,
			PGPOCommentString(context,(ms->comment)),
			PGPOLastOption(context));
	}

	if(ms->Operation!=MS_ENCRYPTCLIPBOARD)
		SCSetProgressNewFilename(ms->hPrgDlg,"From '%s' To '%s'",ms->fileName,TRUE);

	if(!(ms->Operation==MS_ENCRYPTCLIPBOARD))
	{
		char outname[MAX_PATH];

		ms->fileRef=0;
		strcpy(outname,ms->fileName);

		AlterEncryptedFileName(outname,prds->dwOptions);

		LoadString (g_hinst, IDS_ENCFILENAMEPROMPT, StrRes, sizeof(StrRes));

		UserCancel=SaveOutputFile(context,
			ms->hwndWorking, 
			StrRes,
			outname,
			&(ms->fileRef),
			FALSE);

		if(UserCancel)
			return kPGPError_UserAbort;

		PGPAppendOptionList(opts,
			PGPOOutputFile(context,ms->fileRef),
			PGPOLastOption(context));
	}

	// Assume False for For Your Eyes Only
	FYEO=FALSE;

	// These are the only situations we can have FYEO
	if((ms->Operation==MS_ENCRYPTCLIPBOARD) ||
		(FileHasThisExtension(OperationTarget,"txt")))
	{
		// If the recipient dialog has selected it then we're OK
		if((prds->dwOptions & PGPCL_FYEO)==PGPCL_FYEO)
		{
			FYEO=TRUE;
		}
	}

	err = PGPEncode(context,
		opts,
		PGPOPreferredAlgorithms(context,ms->allowedAlgs,ms->nNumAlgs),
		PGPOSendNullEvents(context,75),
		PGPOEventHandler(context,myEvents,ms),
		PGPOVersionString(context,pgpVersionHeaderString),
		PGPOAskUserForEntropy(context, TRUE),
		PGPODataIsASCII(context,DataIsASCII),
		PGPOForYourEyesOnly(context,FYEO),
		PGPOLastOption(context));

	SCSetProgressBar(ms->hPrgDlg,100,TRUE);	

	if(PGPRefIsValid(prds->AddedKeys))
	{
		(void)PGPCountKeys( prds->AddedKeys, &numKeys );
		if ( numKeys > 0) 
		{	
			PGPclQueryAddKeys (context,ms->tlsContext,ms->hwndWorking,
				prds->AddedKeys,NULL);
		}
		PGPFreeKeySet (prds->AddedKeys);
	}

	return err;
}

PGPError EncryptFileListStub (MYSTATE *ms) 
{
	PGPContextRef context;
	PGPFileSpecRef inref;
	PGPOptionListRef opts;
	PGPError err;
	FILELIST *FileCurrent;
	UINT WipeReturn;

	err=kPGPError_NoErr;

	context=ms->context;
	FileCurrent=ms->ListHead;