scdecrypt.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*__________________________________________________________________________
 Copyright (C) 2002 PGP Corporation
 All rights reserved.
 
 $Id: SCdecrypt.c,v 1.12 2002/11/12 18:58:49 pbj Exp $
__________________________________________________________________________*/
#include "precomp.h"

PGPError GenericDecVer(MYSTATE *ms,
					PGPOptionListRef opts,
					char *OperationTarget)
{
	PGPError		err;
	PGPContextRef	context;
	PGPKeyDBRef		newKeysDB = kInvalidPGPKeyDBRef;

	err=kPGPError_NoErr;

	context=ms->context;

	// Use passphrase first if available
	if(ms->PassPhrase)
	{
		PGPAppendOptionList(opts,
			PGPOPassphraseBuffer(context,
				ms->PassPhrase, strlen(ms->PassPhrase) ),
			PGPOLastOption(context));
	}
	else if(ms->PassKey)
	{
		PGPAppendOptionList(opts,
			PGPOPasskeyBuffer(context,
				ms->PassKey,ms->PassKeyLen),
			PGPOLastOption(context));
	}

	ms->fileName=OperationTarget;
	strcpy((char *)ms->verifyName,ms->fileName);
	ms->fileRef=0;
	ms->PassCount=0;
	ms->RecipientKeySet=0;
	ms->RecipientKeyIDArray=0;
	ms->dwKeyIDCount=0;
	ms->obl=NULL;

	if(ms->Operation!=MS_DECRYPTCLIPBOARD)
		PGPscProgressSetNewFilename(ms->hwndWorking,"From '%s' To '%s'",ms->fileName,TRUE);

	PGPNewKeyDB( context, &newKeysDB );

	err = PGPDecode( context, 
					opts,
					PGPOPassThroughIfUnrecognized(context,
						(PGPBoolean)(ms->Operation==MS_DECRYPTCLIPBOARD)),
					PGPOKeyDBRef(context,ms->KeyDB),
					PGPOEventHandler(context,myEvents, ms),
					PGPOImportKeysTo(context,newKeysDB),
					PGPOSendNullEvents(context,75),
					PGPOLastOption(context) );

	// From Synch on Verify
	if(ms->keydbLookup)
		PGPFreeKeyDB(ms->keydbLookup);

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

	AddKeys(ms->hwndWorking,newKeysDB,ms);
	AddKeys(ms->hwndWorking,ms->AddedKeyDB,ms);

	if(ms->RecipientKeySet)
		PGPFreeKeySet(ms->RecipientKeySet);

	if(ms->RecipientKeyIDArray)
		free(ms->RecipientKeyIDArray);

	return err;
}

PGPError DecryptShareFile (MYSTATE *ms,char *szFile)
{
	PFLFileSpecRef		fileref;
	PGPShareFileRef		sharefileref;
	PGPOptionListRef	optionsDecode;
	PGPOptionListRef	optionsEncode;
	PGPShareRef			shares;
	PGPError			err;
	BOOL				UserCancel;
	PGPContextRef		context;
	PGPclRecipientDialogStruct rds;
	PPGPclRecipientDialogStruct prds=&rds;
	char				StrRes[500];
	PGPKeySetRef		recipientSet;

	err=kPGPError_NoErr;
	recipientSet=NULL;

	context=ms->context;

	PGPscProgressSetNewFilename(ms->hwndWorking,"From '%s' To '%s'",szFile,TRUE);

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

	MessageBox(ms->hwndWorking,StrRes,
		PGPscJustFile(szFile),MB_OK|MB_ICONINFORMATION|MB_SETFOREGROUND);

	err = PFLNewFileSpecFromFullPath(PGPPeekContextMemoryMgr (context),
		szFile, &fileref);

	if(IsntPGPError(err))
	{
		err = PGPOpenShareFile (fileref, &sharefileref);
	
		if(IsntPGPError(err))
		{
			ms->PassCount=0;
			ms->RecipientKeySet=0;
			ms->RecipientKeyIDArray=0;
			ms->dwKeyIDCount=0;

			// decrypt specified share file
			PGPBuildOptionList (context, &optionsDecode,
				PGPOKeyDBRef (context, ms->KeyDB),
				PGPOEventHandler (context, myEvents, ms),
				PGPOLastOption (context));
	
			err = PGPCopySharesFromFile (context, sharefileref, 
				optionsDecode, &shares);
	
			AddKeys(ms->hwndWorking,ms->AddedKeyDB,ms);

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

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

				prds->Version=kPGPCurrentRecipVersion;
				prds->hwndParent=ms->hwndWorking;
				prds->szTitle=StrRes;
				prds->context=context;
				prds->tlsContext=ms->tlsContext;
				prds->keydbOriginal=ms->KeyDB;
				prds->dwOptions=kPGPclPassOnly;
				prds->dwDisableFlags=kPGPclDisableASCIIArmor |
					kPGPclDisableWipeOriginal |
					kPGPclDisableAutoMode |
					kPGPclDisableSecureViewer |
					kPGPclDisableSelfDecryptingArchive |
					kPGPclDisableInputIsText;

				UserCancel = !(PGPclRecipientDialog(prds));

				if(!UserCancel)
				{
					if(prds->dwOptions & kPGPclPassOnly)
					{
						LoadString (g_hinst, IDS_SHAREPASSPROMPT, StrRes, sizeof(StrRes));

						UserCancel = PGPclGetPhrase (context,
							ms->KeyDB,
							ms->hwndWorking,
							StrRes,
							&(ms->ConvPassPhrase), 
							NULL,
							NULL, 
							0,
							NULL,
							NULL,
							kPGPclEncryption,
							NULL,NULL,
							1,0,ms->tlsContext,NULL,NULL);

						if(!UserCancel)
						{
							PGPBuildOptionList( context, &optionsEncode,
								PGPOConventionalEncrypt( context,
								PGPOPassphrase( context, ms->ConvPassPhrase ),
								PGPOLastOption( context ) ),
								PGPOLastOption( context ) );
						}
					}
					else
					{
						PGPNewKeySet( prds->keydbSelected, &recipientSet );

						PGPBuildOptionList( context, &optionsEncode,
							PGPOEncryptToKeySet(context,recipientSet),
							PGPOLastOption( context ) );
					}
				}

				if(UserCancel)
				{
					err=kPGPError_UserAbort;
				}
				else
				{
					err = PGPCopySharesToFile( context, sharefileref, 
						optionsEncode, shares );

					if(IsntPGPError(err))
					{
						err = PGPSaveShareFile( sharefileref );
					}

					PGPFreeOptionList(optionsEncode);
				}

				AddKeys(ms->hwndWorking,prds->keydbAdded,ms);

				if(ms->ConvPassPhrase)
				{
					PGPclFreePhrase(ms->ConvPassPhrase);
					ms->ConvPassPhrase=NULL;
				}

				if(prds->keydbSelected)
					PGPFreeKeyDB(prds->keydbSelected);

				PGPFreeShares (shares);
			}

		if(ms->RecipientKeySet)
			PGPFreeKeySet(ms->RecipientKeySet);

		if(ms->RecipientKeyIDArray)
			free(ms->RecipientKeyIDArray);

		PGPFreeOptionList(optionsDecode);
		PGPFreeShareFile (sharefileref);
		}
	PFLFreeFileSpec (fileref);
	}

	if(recipientSet!=NULL)
		PGPFreeKeySet(recipientSet);

	return err;
}

PGPError MacBinaryConversion(PGPFileSpecRef fileRef)
{
	PGPError err;
	PGPUInt32 macCreator,macTypeCode;
	PGPFileSpecRef deMacifiedFSpec;

	err=kPGPError_NoErr;

	deMacifiedFSpec=0;

	err=PGPMacBinaryToLocal(fileRef,
		&deMacifiedFSpec,
		&macCreator,&macTypeCode );

	if(deMacifiedFSpec)
		PGPFreeFileSpec(deMacifiedFSpec);

	return err;
}

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

	err=kPGPError_NoErr;

	context=ms->context;

	FileCurrent=ms->ListHead;

	while(!(PGPscProgressGetCancel(ms->hwndWorking))&&(FileCurrent!=0)&&(IsntPGPError(err)))
	{    
		if(FileCurrent->IsDirectory)
		{
			FileCurrent=FileCurrent->next;
			continue;
		}

		if(FileHasThisExtension(FileCurrent->name,"shf"))
		{
			err=DecryptShareFile(ms,FileCurrent->name);
		
			FileCurrent=FileCurrent->next;			
			continue;
		}

// events handler will ask for output file later...
		PGPNewFileSpecFromFullPath( context,
			FileCurrent->name, &inref);

		PGPBuildOptionList(context,&opts,
			PGPOInputFile(context,inref),
			PGPOLastOption(context) );

		err=GenericDecVer(ms,opts,FileCurrent->name);

		PGPFreeOptionList(opts);

		if((IsntPGPError(err))&&(ms->fileRef))
		{
			err=MacBinaryConversion(ms->fileRef);

			// Try it.. if it's not, go on
			if(err=kPGPError_NotMacBinary)
				err=kPGPError_NoErr;

			PGPclEncDecErrorBox(ms->hwndWorking,err);
		}

		PGPFreeFileSpec(inref);

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

		FileCurrent=FileCurrent->next;				
	}

	return err;
}

BOOL PGPscDecryptFileList(HWND hwnd,char *szApp,void *PGPsc,void *PGPtls,FILELIST *ListHead)
{
	PGPContextRef context;
	MYSTATE *ms;
	PGPtlsContextRef tls;
	PGPError err;
	char *pOutput;
	DWORD dwOutputSize;
	BOOL FYEO;

	err=kPGPError_NoErr;

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

///	if(IsPGPError(PGPlnIsExpired(hwnd, kPGPlnGraceExpiration)))
///		return FALSE;

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

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

		ms->context=context;
		ms->tlsContext=tls;
		ms->ListHead=ListHead;
		ms->Operation=MS_DECRYPTFILELIST;
		ms->szAppName=szApp;

		if(OpenRings(hwnd,context,&(ms->KeyDB),&(ms->bMutable)))
		{
			err=PGPscProgressDialog(hwnd,DoWorkThread,ms,
						  0,"Decoding File(s)...",
						  "","",IDR_DECRYPTAVI);

			FreePhrases(ms);

// If we found no PGP data, warn....
			if(!(ms->FoundPGPData))
				PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_NOPGPINFOINFILE,
							MB_OK|MB_ICONEXCLAMATION);

			if(!PGPscConcatOutBuffList(context,ms->obl,&pOutput,&dwOutputSize,&FYEO))
				PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_OUTOFMEM,
							MB_OK|MB_ICONSTOP);

			if(pOutput)
			{
				if((IsntPGPError(err))&&(FYEO))
				{
					PGPscTempestViewer((void *)context,hwnd,pOutput,dwOutputSize,FYEO);
				}

				memset(pOutput,0x00,dwOutputSize);
				PGPFreeData(pOutput); // Since auto alloced by CDK
			}

			PGPFreeKeyDB(ms->KeyDB);
		}
		free(ms);
	}
	PGPscFreeFileList(ListHead);

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}

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

	err=kPGPError_NoErr;

	context=ms->context;

	PGPBuildOptionList(context,&opts,
		PGPOInputBuffer(context,ms->pInput,ms->dwInputSize),
		PGPOLastOption(context) );

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

	err=GenericDecVer(ms,opts,StrRes);

	PGPFreeOptionList(opts);
	
	return err;
}

BOOL PGPscDecryptClipboard(HWND hwnd,char *szApp,void *PGPsc,void *PGPtls)
{
	PGPContextRef		context;
	MYSTATE *ms;
	char *pInput;
	DWORD dwInputSize;
	UINT ClipboardFormat;
	PGPtlsContextRef tls;
	PGPError err;
	char *pOutput;
	DWORD dwOutputSize;
	BOOL FYEO;

	// 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=PGPscHDropToFileList(hDrop);

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

				return PGPscDecryptFileList(hwnd,szApp,
					PGPsc,PGPtls,ListHead);
			}
		}
		CloseClipboard();
	}

	err=kPGPError_NoErr;

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

///	if(IsPGPError(PGPlnIsExpired(hwnd, kPGPlnGraceExpiration)))
///		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
		{
			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_DECRYPTCLIPBOARD;
				ms->szAppName=szApp;

				if(OpenRings(hwnd,context,&(ms->KeyDB),&(ms->bMutable)))
				{
					err=PGPscProgressDialog(hwnd,DoWorkThread,ms,
						  0,"Decoding Clipboard...",
						  "","",IDR_DECRYPTAVI);

					FreePhrases(ms);

// If no PGP data in clipboard, warn....
					if(!(ms->FoundPGPData))
						PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_NOPGPINFOCLIPBOARD,
							MB_OK|MB_ICONEXCLAMATION);

					if(!PGPscConcatOutBuffList(context,ms->obl,&pOutput,&dwOutputSize,&FYEO))
						PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_OUTOFMEM,
							MB_OK|MB_ICONSTOP);

					if(pOutput)
					{
						if(IsntPGPError(err))
						{
							if((FYEO)||(PGPscGetSecureViewerPref(context)))
							{
								PGPscTempestViewer((void *)context,hwnd,pOutput,dwOutputSize,FYEO);
							}
							else
							{
								TextViewer(hwnd,pOutput,dwOutputSize);
							}
						}

						memset(pOutput,0x00,dwOutputSize);
						PGPFreeData(pOutput); 
					}

					PGPFreeKeyDB(ms->KeyDB);
				}
				free(ms);			
			}
		}
		memset(pInput,0x00,dwInputSize);
		free(pInput);
	}

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}

BOOL PGPscDecryptBuffer(HWND hwnd,char *szApp,void *PGPsc,void *PGPtls,
				   char *pInput,DWORD dwInputSize,
				   char **ppOutput,DWORD *pdwOutputSize,
				   BOOL *pFYEO,OUTBUFFLIST **ppobl,
				   BOOL bNoProgress)
{
	PGPContextRef		context;
	MYSTATE *ms;
	PGPtlsContextRef tls;
	PGPError err;

	err=kPGPError_NoErr;

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

///	if(IsPGPError(PGPlnIsExpired(hwnd, kPGPlnGraceExpiration)))
///		return FALSE;

	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_DECRYPTCLIPBOARD;
		ms->szAppName=szApp;

		if(OpenRings(hwnd,context,&(ms->KeyDB),&(ms->bMutable)))
		{
			if(bNoProgress)
			{
				err=DoWorkThread(hwnd,ms);
			}
			else
			{
				err=PGPscProgressDialog(hwnd,DoWorkThread,ms,
				  0,"Decoding...",
				  "","",IDR_DECRYPTAVI);
			}

			FreePhrases(ms);

			if(ppobl!=NULL)
				*ppobl=ms->obl;
			else
			{
				if(!PGPscConcatOutBuffList(context,ms->obl,ppOutput,pdwOutputSize,pFYEO))
					PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_OUTOFMEM,
					MB_OK|MB_ICONSTOP);
			}

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

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}

/*__Editor_settings____

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