encrypt.c

vc环境下的pgp源码

	while(!(SCGetProgressCancel(ms->hPrgDlg))&&(FileCurrent!=0)&&(IsntPGPError(err)))
	{   
		if(FileCurrent->IsDirectory)
		{
			if(ms->prds->dwOptions & PGPCL_WIPEORIG)
				_rmdir(FileCurrent->name);

			FileCurrent=FileCurrent->next;
			continue;
		}

		// We'll ask for output file in event handler later...
		PGPNewFileSpecFromFullPath( context,
			FileCurrent->name, &inref);

		PGPBuildOptionList(context,&opts,
			PGPOInputFile(context,inref),
			PGPOLastOption(context));
	
		// For SDA's we only have to do this once, so don't
		// do it again on the second+ times
		if(!ms->bDoingSDA)
		{
			err=GenericEncSign(ms,opts,FileCurrent->name);
		}

		PGPFreeOptionList(opts);

		PGPFreeFileSpec( inref );

		if(ms->fileRef)
			PGPFreeFileSpec(ms->fileRef);

		ms->numDone++;
		FileCurrent=FileCurrent->next;				
	}

	// Do any file wiping on a second pass
	if((IsntPGPError(err))&&(ms->prds->dwOptions & PGPCL_WIPEORIG))
	{
		SCSetProgressAVI(ms->hPrgDlg,IDR_ERASEAVI);
		SCSetProgressTitle(ms->hPrgDlg,"Wiping File(s)...");

		FileCurrent=ms->ListHead;
		
		while(!(SCGetProgressCancel(ms->hPrgDlg))&&(FileCurrent!=0)&&(IsntPGPError(err)))
		{   
			if(FileCurrent->IsDirectory)
			{
				// Try to remove directory if we can. Don't
				// worry if we fail (full of new files)
				if(ms->prds->dwOptions & PGPCL_WIPEORIG)
					_rmdir(FileCurrent->name);

				FileCurrent=FileCurrent->next;
				continue;
			}

			WipeReturn=InternalFileWipe(ms->context,
				ms->hwndWorking,
				FileCurrent->name,TRUE);

			if(WipeReturn!=WIPE_OK)
			{
				if (WipeError(ms->hwndWorking,
					FileCurrent,WipeReturn))
				{
					err=kPGPError_UnknownError;
				}
			}

			FileCurrent=FileCurrent->next;
		}
	}

	return err;
}

BOOL EncryptFileList(HWND hwnd,char *szApp,
					 void *PGPsc,
					 void *PGPtls,
					 FILELIST *ListHead,
					 BOOL bEncrypt, 
					 BOOL bSign)

{
	PGPContextRef context;
	PRECIPIENTDIALOGSTRUCT prds;
	MYSTATE *ms;
	char comment[80];
	PGPUInt32 PrefAlg;
	PGPCipherAlgorithm allowedAlgs[20];
	int nNumAlgs;
	PGPtlsContextRef tls;
	PGPError err;
	char StrRes[500];

	err=kPGPError_NoErr;

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

	if(IsPGPError(PGPclEvalExpired(hwnd, PGPCL_ENCRYPTSIGNEXPIRED)))
		return FALSE;

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

	prds=(PRECIPIENTDIALOGSTRUCT)
		malloc(sizeof(RECIPIENTDIALOGSTRUCT));

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

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

		prds->szTitle=StrRes;
		prds->dwDisableFlags=PGPCL_DISABLE_AUTOMODE;
		prds->dwOptions=PGPCL_DETACHEDSIG;

		ms=(MYSTATE *)malloc(sizeof(MYSTATE));

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

			ms->context=context;
			ms->tlsContext=tls;
			ms->ListHead=ListHead;
			ms->Operation=MS_ENCRYPTFILELIST;
			ms->prds=prds;
			ms->Encrypt=bEncrypt; 
			ms->Sign=bSign;
			ms->comment=comment;
			ms->PrefAlg=PrefAlg;
			ms->allowedAlgs=allowedAlgs; 
			ms->nNumAlgs=nNumAlgs;
			ms->szAppName=szApp;

			if(OpenRings(hwnd,context,&(ms->KeySet)))
			{
				err=SCProgressDialog(hwnd,DoWorkThread,ms,
						  0,"Encoding File(s)...",
						  "","",IDR_PROGAVI);

				if(prds->SelectedKeySetRef)
					PGPFreeKeySet(prds->SelectedKeySetRef);

				FreePhrases(ms);

				PGPFreeKeySet(ms->KeySet);
			}
			free(ms);
		}
		free(prds);
	}
	
	FreeFileList(ListHead);

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}

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

	memMgr=PGPGetContextMemoryMgr(context);

	PGPclOpenClientPrefs (memMgr,&PrefRefClient);
	PGPGetPrefBoolean (PrefRefClient,
		kPGPPrefWordWrapEnable, &bWrapReturn);
	PGPGetPrefNumber (PrefRefClient, 
		kPGPPrefWordWrapWidth, &WrapWidth);
	PGPclCloseClientPrefs (PrefRefClient, FALSE);

	*WordWrapThreshold=WrapWidth;

	return bWrapReturn;
}

BOOL WrapBuffer(char **pszOutText,
				char *szInText,
				PGPUInt16 wrapLength)
{
	BOOL RetVal = FALSE;
	PGPError err;
	char *cmdlgBuffer;

	err=PGPclWrapBuffer(
					szInText,
					wrapLength,
					&cmdlgBuffer);

	if(IsntPGPError (err))
	{
		int memamt,length;

		length=strlen(cmdlgBuffer);
		memamt=length+1;

		*pszOutText=(char *)malloc(memamt);
		memcpy(*pszOutText,cmdlgBuffer,length);
		(*pszOutText)[length]=0;
		PGPclFreeWrapBuffer(cmdlgBuffer);
		RetVal = TRUE;
	}

	return RetVal;
}


BOOL WrapIfNecessary(PGPContextRef context,
					 char **pszClipText,DWORD *dwClipSize)
{
	unsigned short WordWrapThreshold;
	char* szWrappedText;
	DWORD dwWrappedSize;

	if(WeNeedToWordWrap(context,&WordWrapThreshold))
	{
		if(TRUE == WrapBuffer(&szWrappedText, 
			*pszClipText,WordWrapThreshold))
		{	
			dwWrappedSize = strlen(szWrappedText);

			memset(*pszClipText,0x00,*dwClipSize);
			free(*pszClipText);
			*pszClipText=szWrappedText;

			*dwClipSize=dwWrappedSize;
		}
	}

	return TRUE;
}

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_BUFFER_SIZE ,&(ms->dwOutputSize)),
		PGPOLastOption(context));

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

	err=GenericEncSign(ms,opts,StrRes);

	PGPFreeOptionList(opts);

	return err;
}

BOOL EncryptClipboard(HWND hwnd,char *szApp,void *PGPsc,void *PGPtls,BOOL Encrypt,BOOL Sign)
{
	PGPContextRef context;
	PRECIPIENTDIALOGSTRUCT prds;
	char *pInput;
	DWORD dwInputSize;
	UINT ClipboardFormat;
	char comment[80];
	PGPUInt32 PrefAlg;
	PGPCipherAlgorithm allowedAlgs[20];
	int nNumAlgs;
	MYSTATE *ms;
	PGPtlsContextRef tls;
	PGPError err;
	char StrRes[500];

	// Check for files copied into clipboard from explorer
	if(OpenClipboard(hwnd)) 
	{
		if(IsClipboardFormatAvailable(CF_HDROP))
		{
			FILELIST *ListHead;
			HDROP hDrop;

			hDrop=(HDROP)GetClipboardData(CF_HDROP);
			ListHead=HDropToFileList(hDrop);

			if(ListHead!=0)
			{
				CloseClipboard();

				return EncryptFileList(hwnd,szApp,
					 PGPsc,PGPtls,ListHead,
					 Encrypt,Sign);
			}
		}
		CloseClipboard();
	}

	err=kPGPError_NoErr;

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

	if(IsPGPError(PGPclEvalExpired(hwnd, PGPCL_ENCRYPTSIGNEXPIRED)))
		return FALSE;

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

	pInput=RetrieveClipboardData(hwnd, &ClipboardFormat, 
			                     &dwInputSize);

	if(!pInput)
	{
		PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_NOCLIPBOARDCONTENTS,
					MB_OK|MB_ICONSTOP);
	}
	else
	{
		if((ClipboardFormat != CF_TEXT)||(*pInput==0))
		{
			PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_NOCLIPBOARDTEXT,
				MB_OK|MB_ICONSTOP);
		}
		else
		{
			WrapIfNecessary(context,&pInput,&dwInputSize);

			prds=(PRECIPIENTDIALOGSTRUCT)
				malloc(sizeof(RECIPIENTDIALOGSTRUCT));

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

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

				prds->szTitle=StrRes;
				prds->dwOptions=PGPCL_ASCIIARMOR;
				prds->dwDisableFlags=PGPCL_DISABLE_ASCIIARMOR |
					PGPCL_DISABLE_WIPEORIG |
					PGPCL_DISABLE_AUTOMODE;

				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->KeySet)))
					{	
						err=SCProgressDialog(hwnd,DoWorkThread,ms,
							  0,"Encoding Clipboard...",
							  "","",IDR_PROGAVI);
	
						if(prds->SelectedKeySetRef)
							PGPFreeKeySet(prds->SelectedKeySetRef);

						FreePhrases(ms);
				
						if((ms->pOutput!=0) && (IsntPGPError(err)))
						{
							StoreClipboardData(hwnd, ms->pOutput, ms->dwOutputSize);
							memset(ms->pOutput,0x00,ms->dwOutputSize);
							PGPFreeData(ms->pOutput); // Since auto alloced by CDK
						}

						PGPFreeKeySet(ms->KeySet);
					}
					free(ms);
				}
				free(prds);
			}
		}
		memset(pInput,0x00,dwInputSize);
		free(pInput);
	}

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}


/*__Editor_settings____

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