icqenc.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 558 行

/*__________________________________________________________________________
 Copyright (C) 2002 PGP Corporation
 All rights reserved.
 
 $Id: ICQenc.c,v 1.18 2002/11/20 16:50:25 pbj Exp $
__________________________________________________________________________*/
#include "precomp.h"

/* Generic event handler */
PGPError
myEvents(
	PGPContextRef context,
	PGPEvent *event,
	PGPUserValue userValue
	)
{
	MYSTATE *s;
	(void) context;

	s = (MYSTATE *)userValue;

	if(PGPscProgressGetCancel(s->hwndWorking))
	{	
		return kPGPError_UserAbort;
	}

	switch( event->type ) 
	{
	case kPGPEvent_NullEvent:
		{	PGPEventNullData *d = &event->data.nullData;

			if(d->bytesTotal!=0)
			{
				return PGPscProgressSetBar(s->hwndWorking,
					(DWORD)(d->bytesWritten*100/d->bytesTotal),FALSE);
			}
		}
		break;
	case kPGPEvent_ErrorEvent:
		{	PGPEventErrorData *d = &event->data.errorData;

			if((d->error!=kPGPError_BadPassphrase)&&
				(d->error!=kPGPError_UserAbort))
				PGPclEncDecErrorBox (s->hwndWorking,d->error); 
		}
		break;
	case kPGPEvent_WarningEvent:
		{	PGPEventWarningData *d = &event->data.warningData;

		}
		break;
	case kPGPEvent_EntropyEvent:
		{	PGPEventEntropyData *d = &event->data.entropyData;
			PGPError err;

			err=PGPclRandom(context, s->hwndWorking, 
				d->entropyBitsNeeded);

			if(err==kPGPError_UserAbort)
			{
				return kPGPError_UserAbort;
			}
		}
		break;
	case kPGPEvent_AnalyzeEvent:
		{	PGPEventAnalyzeData *d = &event->data.analyzeData;

		}
		break;
	case kPGPEvent_BeginLexEvent:
		{	PGPEventBeginLexData *d = &event->data.beginLexData;
			s->sectionCount = d->sectionNumber;
		}
		break;
	case kPGPEvent_EndLexEvent:
		{	PGPEventEndLexData *d = &event->data.endLexData;

		}
		break;
		
	default:
		break;
	}
				
	return kPGPError_NoErr;
}

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

	RetVal=TRUE;

	*comment=0;
	*PrefAlg=kPGPCipherAlgorithm_CAST5;

	err=PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	if(IsntPGPError(err))
	{
		PGPPrefArray *prefArray = NULL;
		int i;

		PGPGetPrefNumber(prefRef,
			kPGPPrefPreferredAlgorithm, 
			PrefAlg);

		err = PGPGetPrefArray(prefRef,
			kPGPPrefAllowedAlgorithmsList, 
			&prefArray);

		if (IsntPGPError(err))
		{
			PGPBoolean aes256=FALSE;
			PGPInt32 num = prefArray->numElements;

			for (i=0; i<num; i++)  
			{
				pAllowedAlgs[i] = (PGPCipherAlgorithm) 
									prefArray->elements[i].data;
				if( pAllowedAlgs[i]==kPGPCipherAlgorithm_AES256 )
					aes256=TRUE;
			}
			
			if( aes256 )  
			{	
					pAllowedAlgs[i++] = kPGPCipherAlgorithm_AES128;
					pAllowedAlgs[i++] = kPGPCipherAlgorithm_AES192;
			}

			*pNumAlgs = i;

			PGPFreePrefArray(prefArray);
		}
		else
			*pNumAlgs = 0;

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

typedef struct
{
	// Client Prefs
	PGPBoolean encryptToSelf;
	PGPKeyDBObjRef defaultKey;
} APREF;

PGPError GrabRecipClientPrefs(HWND hwndParent,
							  PGPContextRef context,
							  PGPKeyDBRef keydb,
							  APREF *apref)
{
	PGPError		err;
	PGPPrefRef		prefRef;

	err = PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	if (IsntPGPError (err))
	{
		PGPGetPrefBoolean(prefRef, kPGPPrefEncryptToSelf,
				&(apref->encryptToSelf));

		if(IsntPGPError(err))
		{
			//err=PGPclGetDefaultPrivateKey(keydb,&(apref->defaultKey));
			err=GetLocalUserKey(keydb,&apref->defaultKey);

			if(IsPGPError(err))
			{
				// Warning message here
				apref->defaultKey=NULL;
				err=kPGPError_NoErr;
			}
		}
	}

	return err;
}

PGPError GenericEncSign(MYSTATE *ms,
					PGPOptionListRef opts,
					char *OperationTarget)
{
	PGPError err;
	PPGPclRecipientDialogStruct prds;
	PGPContextRef	context;
	char StrRes[500],szPassTitle[100];
	PGPKeyDBObjRef Key;
	APREF apref;
	PGPKeySetRef EncKeySet=NULL;

	err=kPGPError_NoErr;	
	
	context=ms->context;

	prds=ms->prds;

	GrabRecipClientPrefs(ms->hwndWorking,
		context,
		ms->KeyDB,
		&apref);
	// If this is first operation, put up recipient/sign dialog

	if(ms->Encrypt)
	{
		Key=MatchICQWithKey(prds->szRecipientArray[0],ms->KeyDB,FALSE);

		if(Key==NULL)
		{
			MessageBox(ms->hwndWorking,
				"No key was found that matches the ICQ user\n"
				"number. Please have the recipient send you\n"
				"his/her PGP key using the Send Key button.",
				"PGP Error",
				MB_OK|MB_ICONSTOP|MB_SETFOREGROUND);
			return kPGPError_UserAbort;
		}

		PGPNewOneKeySet(Key,&EncKeySet);

		if((apref.encryptToSelf)&&(apref.defaultKey!=NULL))
		{
			err = PGPAddKey (apref.defaultKey,EncKeySet);
		}
	}

	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));

		GetLocalUserKey(ms->KeyDB,&(ms->SignKey));

		err=PGPclGetCachedSigningPhrase (context,
			ms->tlsContext,
			ms->hwndWorking, 
			StrRes,
			FALSE, // ForceEntry
			&ms->PassPhrase,
			ms->KeyDB,
			&(ms->SignKey),
//			NULL,
			lpOptions,
			prds->dwFlags,
			&ms->PassKey,
			&ms->PassKeyLen,
			NULL,szPassTitle);
			
		if(err != kPGPError_NoErr)
		{
			PGPclEncDecErrorBox(ms->hwndWorking,err);
			return kPGPError_UserAbort; // UserCancel 
		}
	}

	ms->fileName=OperationTarget;

	// if encrypting, throw in recipients
	if(ms->Encrypt)
	{
		PGPAppendOptionList(opts,
			PGPOEncryptToKeySet(context,EncKeySet),
			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) );
		}
	}

	PGPAppendOptionList(opts,
		PGPOArmorOutput(context, TRUE),
		PGPOLastOption(context));

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

	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,TRUE),
		PGPOLastOption(context));

	PGPscProgressSetBar(ms->hwndWorking,100,TRUE);	

	return err;
}

BOOL WeNeedToWordWrap(PGPContextRef context,
					  unsigned short* WordWrapThreshold)
{
	PGPBoolean	bWrapReturn=TRUE;
	PGPUInt32	WrapWidth=72;
	PGPPrefRef	prefRef;

	PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	PGPGetPrefBoolean (prefRef,
		kPGPPrefWordWrapEnable, &bWrapReturn);
	PGPGetPrefNumber (prefRef, 
		kPGPPrefWordWrapWidth, &WrapWidth);

	*WordWrapThreshold=WrapWidth;

	return bWrapReturn;
}

PGPError EncryptClipboardStub (MYSTATE *ms) 
{
	PGPOptionListRef opts;
	PGPContextRef context;
	PGPError err;
	char StrRes[100];

	err=kPGPError_NoErr;

	context=ms->context;

	PGPBuildOptionList(context,&opts,
		PGPOInputBuffer(context,ms->pInput,ms->dwInputSize),
		PGPOAllocatedOutputBuffer(context,
			&(ms->pOutput),MAX_PGPSize ,&(ms->dwOutputSize)),
		PGPOLastOption(context));

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

	err=GenericEncSign(ms,opts,StrRes);

	PGPFreeOptionList(opts);

	return err;
}

UINT DoWorkThread(HWND hwndWorking,void *pUserValue)
{
	MYSTATE *myState;
	PGPError err;
	DWORD nOleErr;

	err=kPGPError_UnknownError;

	myState=(MYSTATE *)pUserValue;

	myState->hwndWorking=hwndWorking;

	nOleErr = OleInitialize(NULL);

	if ((nOleErr == S_OK) || (nOleErr == S_FALSE))
	{
		err=EncryptClipboardStub (myState);

		OleUninitialize();
	}

	return err;
}

void FreePhrases(MYSTATE *ms)
{
	if(ms->PassPhrase)
	{
		PGPclFreeCachedPhrase(ms->PassPhrase);
		ms->PassPhrase=NULL;
	}

	if(ms->PassKey)
	{
		memset(ms->PassKey,0x00,ms->PassKeyLen);
		PGPFreeData(ms->PassKey);
		ms->PassKey=NULL;
	}
}

BOOL OpenRings(HWND hwnd,PGPContextRef context,PGPKeyDBRef *pkeydb)
{
	PGPError err;

	err=PGPclOpenDefaultKeyrings(context,
		kPGPOpenKeyDBFileOptions_None,pkeydb);

	if(IsPGPError(err))
	{
		MessageBox (hwnd,"PGP Error","Can't Open Rings",
				MB_OK|MB_ICONSTOP);
		return FALSE;
	}
	
	return TRUE;
}

#define IDR_PROGAVI 121

BOOL ICQEncryptBuffer(HWND hwnd,char *szApp,void *PGPsc,void *PGPtls,
				   BOOL Encrypt,BOOL Sign,
				   char *pInput,DWORD dwInputSize,
				   char **pOutput,DWORD *pdwOutputSize,
				   char **szRecipientArray,DWORD dwNumRecipients,
				   BOOL bForce)
{
	PGPContextRef context;
	PPGPclRecipientDialogStruct prds;
	char comment[80];
	PGPUInt32 PrefAlg;
	PGPCipherAlgorithm allowedAlgs[20];
	int nNumAlgs;
	MYSTATE *ms;
	PGPtlsContextRef tls;
	PGPError err;
	char StrRes[500];

	err=kPGPError_NoErr;

	context=(PGPContextRef)PGPsc;
	tls=(PGPtlsContextRef)PGPtls;

	PGPlnLicenseCheck (context);
	if(!PGPlnPGPmailEnabled())
	{
		PGPclNoLicense(hwnd,kPGPclICQplugin);
		return FALSE;
	}

	if(IsPGPError(PGPlnIsExpired(hwnd, kPGPlnOperationStandardExpiration)))
		return FALSE;

	if(!GetCommentLine(context,comment,sizeof(comment),&PrefAlg,
		allowedAlgs, &nNumAlgs))
		return FALSE;

	prds=(PPGPclRecipientDialogStruct)
		malloc(sizeof(PGPclRecipientDialogStruct));

	if(prds)
	{
		memset(prds,0x00,sizeof(PGPclRecipientDialogStruct));

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

		prds->szTitle=StrRes;
		prds->dwOptions=kPGPclASCIIArmor;
		prds->dwDisableFlags=kPGPclDisableASCIIArmor |
			kPGPclDisableWipeOriginal |
			kPGPclDisableInputIsText;

		if(bForce)
			prds->dwDisableFlags|=kPGPclDisableAutoMode;

		prds->dwNumRecipients	= dwNumRecipients;	
		prds->szRecipientArray	= szRecipientArray;

		ms=(MYSTATE *)malloc(sizeof(MYSTATE));
	
		if(ms)
		{
			memset(ms, 0x00, sizeof(MYSTATE) );

			ms->context=context;
			ms->tlsContext=tls;
			ms->pInput=pInput;
			ms->dwInputSize=dwInputSize;
			ms->Operation=MS_ENCRYPTCLIPBOARD;
			ms->prds=prds;
			ms->Encrypt=Encrypt; 
			ms->Sign=Sign;
			ms->comment=comment;
			ms->PrefAlg=PrefAlg;
			ms->allowedAlgs=allowedAlgs; 
			ms->nNumAlgs=nNumAlgs;
			ms->szAppName=szApp;

			if(OpenRings(hwnd,context,&(ms->KeyDB)))
			{	
				err=PGPscProgressDialog(hwnd,DoWorkThread,ms,
					  0,"Encoding...",
					  "","",IDR_PROGAVI);
	
				if(prds->keydbSelected)
					PGPFreeKeyDB(prds->keydbSelected);

				FreePhrases(ms);
				
				if((ms->pOutput!=0) && (IsntPGPError(err)))
				{
					*pOutput=ms->pOutput;
					*pdwOutputSize=ms->dwOutputSize;
				}

				PGPFreeKeyDB(ms->KeyDB);
			}
			free(ms);
		}
		free(prds);
	}

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}


/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/