decryptverify.c

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

						bAlreadyAsked, &szPassPhrase, recipients, keyIDArray,
						keyCount, &pPasskey, &nPasskeyLength, &addedKeys,
						NULL);
			}
			
			if (addedKeys != NULL)
			{
				PGPUInt32 numKeys;
				PGPKeySetRef addedKeySet;

				PGPNewKeySet(addedKeys, &addedKeySet);				
				PGPCountKeys(addedKeySet, &numKeys);
				if (numKeys > 0)
					PGPclImportKeys(context, userData->tlsContext, hwnd, 
						addedKeySet, userData->keyDB, 
						kPGPclNoDialogForValidSingletons);
				
				PGPFreeKeySet(addedKeySet);
				PGPFreeKeyDB(addedKeys);
				addedKeys = NULL;
			}
			
			switch (err)
			{
			case kPGPError_NoErr:
				bAlreadyAsked = TRUE;
				break;
				
			default:
				return err;
			}
			
			if (szPassPhrase != NULL)
			{
				err = PGPAddJobOptions(event->job,
						PGPOPassphrase(context, szPassPhrase),
						PGPOLastOption(context));
				
				PGPclFreeCachedPhrase(szPassPhrase);
				szPassPhrase = NULL;
			}
			else if (pPasskey != NULL)
			{
				err = PGPAddJobOptions(event->job, 
						PGPOPasskeyBuffer(context, pPasskey, nPasskeyLength),
						PGPOLastOption(context));
			}
			
			if (pPasskey != NULL)
			{
				PGPFreeData(pPasskey);
				pPasskey = NULL;
				nPasskeyLength = 0;
			}
		}
		break;

	case kPGPEvent_AnalyzeEvent:
		if (userData->pVerBlock != NULL)
		{
			if (event->data.analyzeData.sectionType == kPGPAnalyze_Encrypted)
				userData->pVerBlock->bEncrypted = TRUE;
		}

		switch (event->data.analyzeData.sectionType)
		{
		case kPGPAnalyze_Encrypted:
			userData->contents |= CONTENTS_ENCRYPTED;
			break;

		case kPGPAnalyze_Signed:
			userData->contents |= CONTENTS_SIGNED;
			break;
		}
		break;

	case kPGPEvent_SignatureEvent:
		{
			PGPEventSignatureData *d = &event->data.signatureData;

			if ((d->signingKey == NULL) && SyncOnVerify(memoryMgr))
			{
				PGPBoolean bGotKeys;
				PGPKeyDBRef keydbNew = NULL;

				PGPclLookupUnknownSigner(context, keyDB, 
					userData->tlsContext, hwnd, event, d->signingKeyID, 
					&bGotKeys,&keydbNew);

				userData->keydbNew = keydbNew;

				if (bGotKeys)
					return kPGPError_NoErr;
			}

			if (userData->pVerBlock == NULL)
				SigEvent(hwnd, context, d, szName);
			else
			{
				if (userData->pVerBlock->previous == NULL)
					CreateVerificationBlock(userData->hInst, context, d,
						userData->pVerBlock->bEncrypted,
						&(userData->pVerBlock->szBlockBegin),
						&(userData->pVerBlock->szBlockEnd));
				else
					CreateVerificationBlock(userData->hInst, context, d,
						userData->pVerBlock->previous->bEncrypted,
						&(userData->pVerBlock->previous->szBlockBegin),
						&(userData->pVerBlock->previous->szBlockEnd));
			}
		}
		break;

	case kPGPEvent_DetachedSignatureEvent:
		{
			int UserCancel;

			pgpAssert(NULL == userData->fsrFileRef);
			UserCancel = GetOriginalFileRef(hwndWorking, context,
				"", NULL,	&(userData->fsrFileRef), hwndWorking, 
				userData->hInst);

			if(UserCancel)
			{
				//s->bVerEncrypted=FALSE;
				return kPGPError_UserAbort;
			}

			PGPAddJobOptions(event->job,
				PGPODetachedSig(context,
					PGPOInputFile(context, userData->fsrFileRef),
					PGPOLastOption(context)),
				PGPOLastOption(context));
		}
		break;

	case kPGPEvent_FinalEvent:
		if (szPassPhrase != NULL)
		{
			PGPclFreeCachedPhrase(szPassPhrase);
			szPassPhrase = NULL;
		}
		if (pPasskey != NULL)
		{
			PGPFreeData(pPasskey);
			pPasskey = NULL;
			nPasskeyLength = 0;
		}
		if (userData->keydbNew != NULL)
		{
			PGPFreeKeyDB(userData->keydbNew);
			userData->keydbNew = NULL;
		}
		if(userData->fsrFileRef != NULL)
		{
			PGPFreeFileSpec(userData->fsrFileRef);
			userData->fsrFileRef = NULL;
		}

		bAlreadyAsked = FALSE;
		break;
	}

	return err;
}


void DisplayErrorCode(char *szFile, int nLine, char *szModule, int nCode,
					  BOOL bKeyrings, HWND hParentWnd)
{
	char szErrorMsg[255];

	if (nCode == kPGPError_BadPacket)
		nCode = kPGPError_CorruptData;

	if (bKeyrings)
		PGPclErrorToString(nCode, szErrorMsg, 254, NULL);
	else
		PGPclEncDecErrorToString(nCode, szErrorMsg, 254);

#ifdef _DEBUG
	_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_WNDW);
	_CrtDbgReport(_CRT_ERROR, szFile, nLine, szModule, szErrorMsg);
#endif

	MessageBox(hParentWnd, szErrorMsg, szModule, MB_ICONEXCLAMATION);
	return;
}


static char * sFindFormatBegin(char *szString, BOOL *pbHTML, BOOL *pbRTF, 
							   BOOL *pbRTFHTML)
{
	char *szSearch = NULL;
	char *szStart;
	char *szEnd;
	char *szFormat;
	char *szAltFormat;
	int nLength;

	szSearch = szString;
	szEnd = szString + strlen(szString) - 6;

	*pbHTML = FALSE;
	*pbRTF = FALSE;
	*pbRTFHTML = FALSE;

	while (strnicmp(szSearch, "<html>", 6) &&
		strnicmp(szSearch, "{\\rtf", 5) &&
		(szSearch < szEnd))
	{
		szSearch++;
	}

	if (szSearch < szEnd)
	{
		szStart = szSearch;
		if (!strnicmp(szSearch, "<html>", 6))
		{
			*pbHTML = TRUE;
			szFormat = "<body";
			szAltFormat = NULL;
		}
		else
		{
			*pbRTF = TRUE;
			szFormat = "\\viewkind";
			szAltFormat = "\\uc";
		}

		nLength = strlen(szFormat);
		szEnd = szString + strlen(szString) - nLength;

		while (strnicmp(szSearch, szFormat, nLength) && (szSearch < szEnd))
			szSearch++;

		if ((szSearch == szEnd) && (szAltFormat != NULL))
		{
			szSearch = szStart;
			nLength = strlen(szAltFormat);
			szEnd = szString + strlen(szString) - nLength;

			while (strnicmp(szSearch, szAltFormat, nLength) && 
				(szSearch < szEnd))
				szSearch++;
		}
	}

	if (*pbRTF)
	{
		char *szHtmlRtf = "\\htmlrtf";
		int nHtmlRtf = strlen(szHtmlRtf);
		int nBack;

		for (nBack=0; nBack<3; nBack++)
		{
			if (!strnicmp(szSearch - nHtmlRtf - nBack, szHtmlRtf, nHtmlRtf))
			{
				szSearch -= nHtmlRtf + nBack;
				*pbRTFHTML = TRUE;
				break;
			}
		}

		return szSearch;
	}

	if (szSearch < szEnd)
	{
		szFormat = ">";
		nLength = strlen(szFormat);
		szEnd = szString + strlen(szString) - nLength;

		while (strnicmp(szSearch, szFormat, nLength) && (szSearch < szEnd))
			szSearch++;
	}

	if (szSearch < szEnd)
		szSearch += nLength;
	else
	{
		szSearch = NULL;
		*pbHTML = FALSE;
	}

	return szSearch;
}


static char * sFindFormatEnd(char *szString, BOOL bRTF)
{
	char *szSearch = NULL;
	char *szFormat;
	int nLength;

	if (bRTF)
		szFormat = "}";
	else
		szFormat = "</body>";

	nLength = strlen(szFormat);
	szSearch = szString + strlen(szString) - nLength;

	while (strnicmp(szSearch, szFormat, nLength) && (szSearch > szString))
		szSearch--;

	if (szSearch == szString)
		szSearch = NULL;

	return szSearch;
}


static void WriteFileOrBuffer(PGPMemoryMgrRef mgr, HANDLE hFile, 
							  char **szBuffer, char *szData,
							  int nDataLength, DWORD *pBytesWritten)
{
	if (hFile != NULL)
		WriteFile(hFile, szData, nDataLength, pBytesWritten, NULL);

	if (szBuffer != NULL)
	{
		int nOrigLength = strlen(*szBuffer);

		PGPReallocData(mgr, szBuffer, nOrigLength + nDataLength + 1, 0);
		memcpy(*szBuffer + nOrigLength, szData, nDataLength);
		(*szBuffer)[nOrigLength + nDataLength] = 0;
	}

	return;
}


static void	WriteDecryptedMimeParts(PGPMemoryMgrRef mgr,
									VerificationBlock *pVerBlock, 
									MimePart *pMimeList,
									MimePart **ppMimeFooter,
									HANDLE hFile,
									char **szOutBuffer)
{
	DWORD dwWritten;
	BOOL bMultipartMixed = FALSE;
	BOOL bMultipartAlt = FALSE;
	BOOL bWroteHeader = FALSE;
	BOOL bWriteFooter = FALSE;
	MimePart *grandparentPart = NULL;
	MimePart *pMimeFooter = NULL;

	if (pMimeList->parentPart != NULL)
	{
		if (pMimeList->parentPart->nContentType == ContentType_MultipartMixed)
			bMultipartMixed = TRUE;

		if (pMimeList->parentPart->nContentType == ContentType_MultipartAlternative)
			bMultipartAlt = TRUE;

		grandparentPart = pMimeList->parentPart->parentPart;
	}

	bWroteHeader = FALSE;
	while (pMimeList != NULL)
	{
		if (pMimeList->parentPart != NULL)
		{
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, "--", 2, &dwWritten);
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, 
				pMimeList->parentPart->szBoundary, 
				pMimeList->parentPart->nBoundaryLength, &dwWritten);
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, "\r\n", 2, &dwWritten);
		}

		if (pMimeList->szHeader)
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, 
				pMimeList->szHeader, pMimeList->nHeaderLength, &dwWritten);

		if (pMimeList->subPart != NULL)
			WriteDecryptedMimeParts(mgr, pVerBlock, pMimeList->subPart, 
				&pMimeFooter, hFile, szOutBuffer);

		if ((pMimeList->nContentType != ContentType_MultipartMixed) &&
			(pMimeList->nContentType != ContentType_MultipartAlternative))
		{
			if (((!bMultipartAlt && !bWroteHeader) || bMultipartAlt) &&
				!(pMimeList->bAttachment))
			{
				bWroteHeader = TRUE;

				if (pMimeList->nContentType == ContentType_TextHTML)
				{
					char szTemp[] = "<html><pre>\r\n";
					
					WriteFileOrBuffer(mgr, hFile, szOutBuffer, szTemp, 
						strlen(szTemp), &dwWritten);
				}
				
				WriteFileOrBuffer(mgr, hFile, szOutBuffer, 
					pVerBlock->szBlockBegin, strlen(pVerBlock->szBlockBegin), 
					&dwWritten);
				
				if (pMimeList->nContentType == ContentType_TextHTML)
				{
					char szTemp[] = "</html>\r\n";
					
					WriteFileOrBuffer(mgr, hFile, szOutBuffer, szTemp, 
						strlen(szTemp), &dwWritten);
				}
			}

			WriteFileOrBuffer(mgr, hFile, szOutBuffer, pMimeList->szBody, 
				pMimeList->nBodyLength, &dwWritten);

			if ((grandparentPart != NULL) && (pMimeList->parentPart != NULL))
			{
				if (pMimeList->parentPart->nextPart == NULL)
					bWriteFooter = TRUE;

				pMimeFooter = pMimeList->parentPart;
			}
			else if (!(pMimeList->bAttachment))
			{
				if (pMimeList->nextPart != NULL)
				{
					if (!(pMimeList->nextPart->bAttachment))
						bWriteFooter = TRUE;
				}
				else
					bWriteFooter = TRUE;

				pMimeFooter = pMimeList;
			}
			else if (pMimeList->nextPart == NULL)
			{
				bWriteFooter = TRUE;
				pMimeFooter = pMimeList;
			}
		}

		if (ppMimeFooter != NULL)
			*ppMimeFooter = pMimeFooter;
		
		if (bWriteFooter)
		{
			MimePart *tempPart = pMimeFooter->nextPart;

			pMimeFooter->nextPart = NULL;
			WriteDecryptedMimeFooter(mgr, pVerBlock, pMimeFooter, hFile, 
				szOutBuffer);
			pMimeFooter->nextPart = tempPart;
		}

		if (pMimeList->subPart != NULL)
		{
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, "--", 2, &dwWritten);
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, pMimeList->szBoundary, 
				pMimeList->nBoundaryLength, &dwWritten);
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, "--\r\n", 4, 
				&dwWritten);
		}

		pMimeList = pMimeList->nextPart;
	}

	return;
}


static void	WriteDecryptedMimeFooter(PGPMemoryMgrRef mgr,
									 VerificationBlock *pVerBlock, 
									 MimePart *pMimeList,
									 HANDLE hFile,
									 char **szOutBuffer)
{
	DWORD dwWritten;
	MimePart *grandparentPart = NULL;
	MimePart *thisPart;

	if (pMimeList->parentPart != NULL)
		grandparentPart = pMimeList->parentPart->parentPart;

	while (pMimeList != NULL)
	{
		if (pMimeList->bAttachment)
		{
			thisPart = pMimeList->previousPart;
			while (thisPart->bAttachment && thisPart->previousPart)
				thisPart = thisPart->previousPart;
		}
		else
			thisPart = pMimeList;

		if (((pMimeList->parentPart != NULL) && (grandparentPart != NULL))
			|| pMimeList->bAttachment)
		{
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, "--", 2, &dwWritten);
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, 
				pMimeList->parentPart->szBoundary, 
				pMimeList->parentPart->nBoundaryLength, &dwWritten);
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, "\r\n", 2, &dwWritten);

			WriteFileOrBuffer(mgr, hFile, szOutBuffer, thisPart->szHeader, 
				thisPart->nHeaderLength, &dwWritten);
		}
		
		if (thisPart->subPart != NULL)
			WriteDecryptedMimeFooter(mgr, pVerBlock, thisPart->subPart, hFile,
				szOutBuffer);
		
		if ((thisPart->nContentType != ContentType_MultipartMixed) &&
			(thisPart->nContentType != ContentType_MultipartAlternative))
		{
			if (thisPart->nContentType == ContentType_TextHTML)
			{
				char szTemp[] = "<html><pre>\r\n";
				
				WriteFileOrBuffer(mgr, hFile, szOutBuffer, szTemp, 
					strlen(szTemp), &dwWritten);
			}
			
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, pVerBlock->szBlockEnd, 
				strlen(pVerBlock->szBlockEnd), &dwWritten);
			
			if (thisPart->nContentType == ContentType_TextHTML)
			{
				char szTemp[] = "</html>\r\n";
				
				WriteFileOrBuffer(mgr, hFile, szOutBuffer, szTemp, 
					strlen(szTemp), &dwWritten);
			}
		}

		if ((pMimeList->nextPart == NULL) && (pMimeList->parentPart != NULL)
			&& (grandparentPart != NULL))
		{
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, "--", 2, &dwWritten);
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, 
				pMimeList->parentPart->szBoundary, 
				pMimeList->parentPart->nBoundaryLength, &dwWritten);
			WriteFileOrBuffer(mgr, hFile, szOutBuffer, "--\r\n", 4, &dwWritten);
		}

		pMimeList = pMimeList->nextPart;
	}
}


/*__Editor_settings____

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