📄 decryptverify.c

📁 PGP8.0源码请认真阅读您的文件包然后写出其具体功能
💻 C
📖 第 1 页 / 共 3 页
字号:
			DisplayErrorCode(__FILE__, __LINE__, szModule, err, FALSE, hwnd);
			goto DecryptVerifyFileError;
		}
		
		err = PGPBuildOptionList(context, &options, 
				PGPOInputFile(context, inputFile),
				PGPOOutputFile(context, outputFile),
				PGPOLastOption(context));
	}
	else
	{
		pVerBlock = (VerificationBlock *) PGPNewData(memoryMgr,
											sizeof(VerificationBlock),
											kPGPMemoryMgrFlags_Clear);

		pVerBlock->next = NULL;
		pVerBlock->szBlockBegin = NULL;
		pVerBlock->szBlockEnd = NULL;
		pVerBlock->pOutput = NULL;
		pVerBlock->outSize = 0;
		pVerBlock->bEncrypted = FALSE;
		pVerBlock->FYEO = FALSE;

		err = PGPBuildOptionList(context, &options, 
				PGPOInputFile(context, inputFile),
				PGPOLastOption(context));
	}

		
	if (IsPGPError(err))
	{
		DisplayErrorCode(__FILE__, __LINE__, szModule, err, FALSE, hwnd);
		goto DecryptVerifyFileError;
	}

	err = DecryptVerify(hInst, hwnd, context, tlsContext, szName, szModule, 
			options, bMIME, pVerBlock, !bBinary, &bKeysOnly);

	if (!bBinary)
	{
		HANDLE hFile;
		DWORD dwWritten;
		BOOL bFixed = FALSE;

		hFile = CreateFile(szOutFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
					FILE_ATTRIBUTE_NORMAL, NULL);

		pTempBlock = pVerBlock;
		while (pVerBlock != NULL)
		{
			if (pVerBlock->FYEO)
				bDoFYEO = TRUE;

			pVerBlock = pVerBlock->next;
		}
		pVerBlock = pTempBlock;

		if (bDoFYEO || (PGPscGetSecureViewerPref((void *)context)))
		{
			// Convert pVerBlock to OUTBUFFLIST
			do
			{
				if (pVerBlock->szBlockBegin != NULL)
				{
					nobl=PGPscMakeOutBuffItem(&obl);
					nobl->pBuff=pVerBlock->szBlockBegin;
					nobl->dwBuffSize=strlen(pVerBlock->szBlockBegin);
				}
				
				if (pVerBlock->pOutput != NULL)
				{
					nobl=PGPscMakeOutBuffItem(&obl);
					nobl->pBuff=pVerBlock->pOutput;
					nobl->dwBuffSize=strlen(pVerBlock->pOutput);

					if (PGPscGetSecureViewerPref((void *)context))
						nobl->FYEO = TRUE;
					else
					{
						nobl->FYEO=pVerBlock->FYEO;
						if (nobl->FYEO)
							bFYEO = TRUE;
					}
				}
				
				if (pVerBlock->szBlockEnd != NULL)
				{
					nobl=PGPscMakeOutBuffItem(&obl);
					nobl->pBuff=pVerBlock->szBlockEnd;
					nobl->dwBuffSize=strlen(pVerBlock->szBlockEnd);
				}
				
				pTempBlock = pVerBlock;
				pVerBlock=pVerBlock->next;
				PGPFreeData(pTempBlock);
			}
			while (pVerBlock != NULL);
			
			// Concatinate them to ppOutput
			PGPscConcatOutBuffList((void *)context,
				obl,
				(char **)ppOutput,
				pOutSize,
				FYEO);

			/* We don't want to show the FYEO warning if the user has
			   "Always use Secure Viewer" on */

			*FYEO = bFYEO;
		}
		else do
		{
			// Fix for Eudora 4.0.1 bug where "boundary=..." is on
			// a separate line

			if (pVerBlock->szBlockBegin != NULL)
			{
				if (!bMIME)
				{
					WriteFile(hFile, pVerBlock->szBlockBegin, 
						strlen(pVerBlock->szBlockBegin), &dwWritten, 
						NULL);
						
					WriteFile(hFile, pVerBlock->pOutput, 
						strlen((char *) pVerBlock->pOutput), &dwWritten, 
						NULL);
					
					WriteFile(hFile, pVerBlock->szBlockEnd, 
						strlen(pVerBlock->szBlockEnd), &dwWritten, NULL);
					
					PGPFreeData(pVerBlock->szBlockBegin);
					PGPFreeData(pVerBlock->pOutput);
					PGPFreeData(pVerBlock->szBlockEnd);
				}
				else
				{
					BOOL bMultiMixed = FALSE;
					BOOL bMultiAlt = FALSE;
					BOOL bFirstMimePart = FALSE;
					MimePart *pMimeList = NULL;
					MimePart *pFirstMimeList = NULL;
					
					ParseMime((char *) pVerBlock->pOutput, &pMimeList);

					if (pMimeList != NULL)
					{
						char szTemp[] = "Mime-Version: 1.0\r\n";

						WriteFile(hFile, szTemp, strlen(szTemp), &dwWritten,
							NULL);
						WriteDecryptedMimeParts(memoryMgr, pVerBlock, 
							pMimeList, NULL, hFile, NULL);
					}

					FreeMimeList(pMimeList);
					PGPFreeData(pVerBlock->szBlockBegin);
					PGPFreeData(pVerBlock->pOutput);
					PGPFreeData(pVerBlock->szBlockEnd);
				}
			}
			else if (pVerBlock->pOutput != NULL)
			{
				WriteFile(hFile, pVerBlock->pOutput, 
					strlen((char *) pVerBlock->pOutput), &dwWritten, 
					NULL);
				
				PGPFreeData(pVerBlock->pOutput);
			}
				
			pTempBlock = pVerBlock;
			pVerBlock = pTempBlock->next;
			PGPFreeData(pTempBlock);
		}
		while (pVerBlock != NULL);
			
		CloseHandle(hFile);

		*pszOutFile = (char *) PGPNewData(memoryMgr,
									strlen(szOutFile)+1,
									kPGPMemoryMgrFlags_Clear);
		strcpy(*pszOutFile, szOutFile);
	}
	else
	{
		PGPMacBinaryToLocal(outputFile, &finalFile, &macCreator, &macType);
		if (finalFile != NULL)
			PGPGetFullPathFromFileSpec(finalFile, pszOutFile);
		else
		{
			*pszOutFile = (char *) PGPNewData(memoryMgr,
										strlen(szOutFile)+1,
										kPGPMemoryMgrFlags_Clear);
			strcpy(*pszOutFile, szOutFile);
		}

		if (bKeysOnly)
		{
			DeleteFile(*pszOutFile);
			PGPFreeData(*pszOutFile);
			*pszOutFile = NULL;
		}
	}

DecryptVerifyFileError:

	if (finalFile != NULL)
		PGPFreeFileSpec(finalFile);

	if (inputFile != NULL)
		PGPFreeFileSpec(inputFile);

	if (outputFile != NULL)
		PGPFreeFileSpec(outputFile);

	if (options != NULL)
		PGPFreeOptionList(options);

	if (szOutFile != NULL)
		free(szOutFile);

	return err;
}


PGPError DecryptVerify(HINSTANCE hInst, HWND hwnd, PGPContextRef context, 
					   PGPtlsContextRef tlsContext, 
					   char *szName, char *szModule,
					   PGPOptionListRef options, BOOL bMIME,
					   VerificationBlock *pVerBlock, BOOL bImportIfKeysOnly,
					   BOOL *bKeysOnly)
{
	PGPError			err			= kPGPError_NoErr;
	PGPKeyDBRef			keyDB		= NULL;
	PGPKeyDBRef			newKeyDB	= NULL;
	PGPOptionListRef	tempOptions	= NULL;
	PGPUInt32			nNumKeys	= 0;
	HWND				hwndWorking	= NULL;
	char				szWorkingTitle[256];
	DecodeEventData		decodeData;

	UpdateWindow(hwnd);

#if PGP_NOTES
	// Check license number and expiration with clientlib functions.
	// This is to avoid having to compile all the PGPlnLib code into
	// the Notes plugin
	if(!PGPclPGPdesktopEnabled())
	{
		PGPclNoLicense(hwnd,kPGPclLotusNotesPlugin);
		return kPGPError_UserAbort;
	}

	// Check for demo expiration
	if (PGPclIsExpired(hwnd,
			(PGPclExpType)kPGPlnOperationGraceExpiration) != kPGPError_NoErr)
	{
		PGPclErrorBox(hwnd, kPGPError_Win32_Expired);
		return kPGPError_UserAbort;
	}
#else
	// Check license number and expiration with static library functions.
	// This makes it more difficult to crack.
	PGPlnLicenseCheckLite (context);
	if(!PGPlnPGPmailEnabled())
	{
		PGPclNoLicense(hwnd,kPGPclPGPmailPlugin);
		return kPGPError_UserAbort;
	}
	// Check for expiration
	if (PGPlnIsExpired(hwnd, kPGPlnOperationGraceExpiration) != kPGPError_NoErr)
		return kPGPError_UserAbort;
#endif
	
	decodeData.hInst		= hInst;
	decodeData.hwnd			= hwnd;
	decodeData.tlsContext	= tlsContext;
	decodeData.szName		= szName;
	decodeData.recipients	= NULL;
	decodeData.keyCount		= 0;
	decodeData.keyIDArray	= NULL;
	decodeData.pVerBlock	= pVerBlock;
	decodeData.contents		= 0;
	decodeData.fsrFileRef   = NULL;

	*bKeysOnly = FALSE;

	err = PGPclOpenDefaultKeyrings(context, kPGPOpenKeyDBFileOptions_Mutable, 
			&keyDB);

	if (IsPGPError(err))
		err = PGPclOpenDefaultKeyrings(context, kPGPOpenKeyDBFileOptions_None, 
				&keyDB);

	if (IsPGPError(err))
	{
		DisplayErrorCode(__FILE__, __LINE__, szModule, err, TRUE, hwnd);
		goto DecryptVerifyError;
	}

	decodeData.keyDB = keyDB;
	decodeData.keydbNew = NULL;
	PGPNewKeyDB(context, &newKeyDB);

	LoadString(hInst, IDS_WORKINGDECRYPT, szWorkingTitle, 
		sizeof(szWorkingTitle));

	hwndWorking = WorkingDlgProcThread(GetModuleHandle(szModule), hInst, hwnd,
					szWorkingTitle, "");
	decodeData.hwndWorking = hwndWorking;

	err = PGPDecode(context,
			options,
			PGPOPassThroughIfUnrecognized(context, (PGPBoolean) !bMIME),
			PGPOPassThroughKeys(context, TRUE),
			PGPOEventHandler(context, DecodeEventHandler, &decodeData),
			PGPOSendNullEvents(context, 100),
			PGPOImportKeysTo(context, newKeyDB),
			PGPOKeyDBRef(context, decodeData.keyDB),
			PGPOLastOption(context));

	WorkingCallback(hwndWorking, -1, -1);

	if (IsPGPError(err) && (err != kPGPError_UserAbort))
	{
		DisplayErrorCode(__FILE__, __LINE__, szModule, err, FALSE, hwnd);
		goto DecryptVerifyError;
	}

	if (newKeyDB != NULL)
	{
		PGPKeySetRef newKeySet;

		PGPNewKeySet(newKeyDB, &newKeySet);
		PGPCountKeys(newKeySet, &nNumKeys);

		if (nNumKeys > 0)
		{
			if (!(decodeData.contents & CONTENTS_ENCRYPTED) && 
				!(decodeData.contents & CONTENTS_SIGNED))
				*bKeysOnly = TRUE;

			if (bImportIfKeysOnly || !(*bKeysOnly))
				PGPclImportKeys(context, tlsContext, hwnd, newKeySet, keyDB, 0);
		}

		PGPFreeKeySet(newKeySet);
	}

DecryptVerifyError:

	if (decodeData.recipients != NULL)
		PGPFreeKeySet(decodeData.recipients);

	if (decodeData.keyIDArray != NULL)
		free(decodeData.keyIDArray);

	if (newKeyDB != NULL)
		PGPFreeKeyDB(newKeyDB);

	if (keyDB != NULL)
		PGPFreeKeyDB(keyDB);

	return err;
}


BOOL GetOriginalFileRef(HWND hwnd,PGPContextRef context,
						char *InputFile,
						char *OutputFile,
						PGPFileSpecRef *OriginalFileRef,
						HWND hwndWorking, HINSTANCE hInst)
{
	char OriginalFile[MAX_PATH+1]={0};
	char *pTempPtr = NULL;
	BOOL bCancelled = FALSE;
	OPENFILENAME ofnStruct={0};
	char szFileFilter[500]={0};
	char szOpenFileTitle[500]={0};

	pgpAssert(NULL != InputFile);
	pgpAssert(NULL != OriginalFileRef);

	strcpy(OriginalFile, InputFile);

	LoadString (hInst, IDS_SAVEFILTER, szFileFilter, sizeof(szFileFilter));
	while (pTempPtr = strrchr (szFileFilter, '@')) 
		*pTempPtr = '\0';

	LoadString (hInst, IDS_SELSIGNFILE, szOpenFileTitle, sizeof(szOpenFileTitle));

	ofnStruct.lStructSize=sizeof(ofnStruct); 
    ofnStruct.hwndOwner=hwnd; 
    ofnStruct.lpstrFilter=szFileFilter; 
    ofnStruct.nFilterIndex=1; 
    ofnStruct.lpstrFile=OriginalFile; 
    ofnStruct.nMaxFile=MAX_PATH; 
    ofnStruct.lpstrTitle=szOpenFileTitle; 
    ofnStruct.Flags=OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY |
						   OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_NOCHANGEDIR;
#ifdef WIN32
	ofnStruct.Flags=ofnStruct.Flags | OFN_EXPLORER;
#endif

	if(GetOpenFileName(&ofnStruct))
	{
		PGPNewFileSpecFromFullPath(context, OriginalFile, OriginalFileRef);
	}
	else
		bCancelled = TRUE;

	return bCancelled;
}

PGPError DecodeEventHandler(PGPContextRef context, 
							PGPEvent *event, 
							PGPUserValue userValue)
{
	HWND			hwnd			= NULL;
	char *			szPassPhrase	= NULL;
	PGPByte *		pPasskey		= NULL;
	PGPUInt32		nPasskeyLength	= 0;
	static BOOL		bAlreadyAsked	= FALSE;
	char *			szName			= NULL;
	PGPMemoryMgrRef	memoryMgr		= NULL;
	PGPKeyDBRef		keyDB			= NULL;
	PGPKeyDBRef		addedKeys		= NULL;
	PGPKeySetRef	recipients		= NULL;
	PGPUInt32		keyCount		= 0;
	PGPKeyID		*keyIDArray		= NULL;
	DecodeEventData	*userData		= NULL;
	HWND			hwndWorking		= NULL;
	PGPError		err				= kPGPError_NoErr;

	pgpAssert(context != NULL);
	pgpAssert(event != NULL);

	userData = (DecodeEventData *) userValue;

	hwnd			= userData->hwnd;
	hwndWorking		= userData->hwndWorking;
	szName			= userData->szName;
	keyDB			= userData->keyDB;
	recipients		= userData->recipients;
	keyCount		= userData->keyCount;
	keyIDArray		= userData->keyIDArray;

	memoryMgr = PGPPeekContextMemoryMgr(context);

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

			bCancel = WorkingCallback (	hwndWorking, 
										(unsigned long)d->bytesWritten, 
										(unsigned long)d->bytesTotal) ;

			if(bCancel)
			{
				return kPGPError_UserAbort;
			}
		}
		break;

	case kPGPEvent_BeginLexEvent:
		if (userData->pVerBlock != NULL)
		{
			userData->pVerBlock->bEncrypted = FALSE;
		}
		break;

	case kPGPEvent_OutputEvent:
		if (userData->pVerBlock != NULL)
		{
			PGPEventOutputData *d = &event->data.outputData;

			// Added FYEO member for tempest viewer
			userData->pVerBlock->FYEO=d->forYourEyesOnly;

			PGPAddJobOptions(event->job,
				PGPOAllocatedOutputBuffer(context, 
					&(userData->pVerBlock->pOutput), 
					INT_MAX, 
					&(userData->pVerBlock->outSize)),
				PGPOLastOption(context));

			userData->pVerBlock->next = (VerificationBlock *) 
				PGPNewData(memoryMgr,
					sizeof(VerificationBlock),
					kPGPMemoryMgrFlags_Clear);

			userData->pVerBlock->next->previous = userData->pVerBlock;
			userData->pVerBlock = userData->pVerBlock->next;
			userData->pVerBlock->szBlockBegin = NULL;
			userData->pVerBlock->szBlockEnd = NULL;
			userData->pVerBlock->pOutput = NULL;
			userData->pVerBlock->outSize = 0;
			userData->pVerBlock->bEncrypted = FALSE;
			userData->pVerBlock->FYEO = FALSE;
		}
		break;

	case kPGPEvent_RecipientsEvent:
		{
			PGPEventRecipientsData	*eventData; 

			eventData = &(event->data.recipientsData);

			if (eventData->recipientSet != NULL)
			{
				PGPIncKeySetRefCount(eventData->recipientSet);
				userData->recipients = eventData->recipientSet;
			}

			userData->keyCount = eventData->keyCount;

			if (eventData->keyCount > 0)
			{
				UINT i;

				userData->keyIDArray =	(PGPKeyID *) 
										calloc(sizeof(PGPKeyID),
												eventData->keyCount);

				for (i=0; i<eventData->keyCount; i++)
					userData->keyIDArray[i] = eventData->keyIDArray[i];
			}
			else
				userData->keyIDArray = NULL;
		}
		break;

	case kPGPEvent_PassphraseEvent:
		{
			char szPrompt[256];
			PGPEventPassphraseData *d = &event->data.passphraseData;

			if (bAlreadyAsked)
				LoadString(userData->hInst, IDS_PASSPHRASEREENTER, szPrompt, 
					sizeof(szPrompt));
			else
				LoadString(userData->hInst, IDS_PASSPHRASEPROMPT, szPrompt, 
					sizeof(szPrompt));

			// Don't cache conventional passphrases
			if(d->fConventional)
			{
				err = PGPclGetConventionalPhrase(context, hwnd, szPrompt,
						&szPassPhrase);
			}
			else
			{
				err = PGPclGetCachedDecryptionPhrase(context, 
						userData->tlsContext, keyDB, hwnd, szPrompt,
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -