encryptsign.c

vc环境下的pgp源码

						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err);
						goto EncryptSignError;
					}
	
					PGPFreeOptionList(encryptOptions);
					encryptOptions = tempOptions;
				}
				
				if (prds->dwOptions & PGPCL_PASSONLY)
				{
					if (!bGotConvPass)
					{
						char szPrompt[256];
						
						LoadString(hInst, IDS_CONVPASSPHRASE, szPrompt, 
							sizeof(szPrompt));
						
						err = PGPclGetPhrase(context, pubKeySet, hwnd, 
								szPrompt, &szConvPass, NULL, NULL, 0, NULL, 
								NULL, PGPCL_ENCRYPTION, NULL, NULL, 1, 0, 
								NULL, NULL,NULL);
						
						// wjb changed to 1 for min passphrase length
						if (err == kPGPError_UserAbort)
							goto EncryptSignError;
						
						nConvPassLen = strlen(szConvPass);
						bGotConvPass = TRUE;
					}
					
					GetPreferredAlgorithm(memoryMgr, &prefAlg);
					
					err = PGPBuildOptionList(context, &tempOptions,
							encryptOptions,
							PGPOConventionalEncrypt(context,
								PGPOPassphraseBuffer(context,
									szConvPass, 
									nConvPassLen),
								PGPOLastOption(context)),
							PGPOCipherAlgorithm(context, prefAlg),
							PGPOLastOption(context));
					
					if (IsPGPError(err))
					{
						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err);
						goto EncryptSignError;
					}
				}
				else
				{
					GetAllowedAlgorithms(memoryMgr, allowedAlgs, &nNumAlgs);
					recipKeySet = prds->SelectedKeySetRef;
					
					err = PGPBuildOptionList(context, &tempOptions,
							encryptOptions,
							PGPOPreferredAlgorithms(context,
								allowedAlgs, nNumAlgs ),
							PGPOEncryptToKeySet(context, recipKeySet),
							PGPOFailBelowValidity(context, 
								kPGPValidity_Unknown),
							PGPOWarnBelowValidity(context, 
								kPGPValidity_Unknown),
							PGPOLastOption(context));
					
					if (IsPGPError(err))
					{
						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err);
						goto EncryptSignError;
					}
				}
				
				PGPFreeOptionList(encryptOptions);
				encryptOptions = tempOptions;
			}
		}
		
		if (bSign)
		{
			if (*pSignOptions == NULL)
			{
				char szPrompt[256];

				if (bGotPassphrase)
					LoadString(hInst, IDS_PASSPHRASEREENTER, szPrompt, 
						sizeof(szPrompt));
				else
					LoadString(hInst, IDS_PASSPHRASEPROMPT, szPrompt, 
						sizeof(szPrompt));
				
				err = PGPclGetCachedSigningPhrase(context, tlsContext, hwnd, 
						szPrompt, bGotPassphrase, &szPassphrase, 
						pubKeySet, &signKey, NULL, NULL, prds->dwFlags,
						&pPasskey, &nPasskeyLength, &addedKeys,NULL);
				
				if (addedKeys != NULL)
				{
					PGPUInt32 numKeys;

					PGPCountKeys(addedKeys, &numKeys);
					if (numKeys > 0)
						PGPclQueryAddKeys(context, tlsContext, hwnd, 
							addedKeys, NULL);

					PGPFreeKeySet(addedKeys);
					addedKeys = NULL;
				}

				if (IsPGPError(err))
				{
					if (err != kPGPError_UserAbort)
						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err);
					goto EncryptSignError;
				}
				
				bGotPassphrase = TRUE;
				if (IsntNull(szPassphrase))
				{
					nPassphraseLen = strlen(szPassphrase);
				
					err = PGPBuildOptionList(context, pSignOptions,
							PGPOSignWithKey(context, 
								signKey, 
								PGPOPassphraseBuffer(context,
									szPassphrase, 
									nPassphraseLen),
								PGPOLastOption(context)),
							PGPOLastOption(context));
				}
				else if (IsntNull(pPasskey))
				{
					err = PGPBuildOptionList(context, pSignOptions,
							PGPOSignWithKey(context, 
								signKey, 
								PGPOPasskeyBuffer(context,
									pPasskey, 
									nPasskeyLength),
								PGPOLastOption(context)),
							PGPOLastOption(context));
				}
				
				if (IsPGPError(err))
				{
					if (err != kPGPError_UserAbort)
						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err);
					goto EncryptSignError;
				}
			}

			err = PGPBuildOptionList(context, &tempOptions,
					options,
					PGPOClearSign(context, 
						(PGPBoolean) (!bEncrypt && !bBinary)),
					PGPOLastOption(context));
			
			if (IsPGPError(err))
			{
				if (err != kPGPError_UserAbort)
					DisplayErrorCode(__FILE__, __LINE__, szModule, 
						err);
				goto EncryptSignError;
			}

			PGPFreeOptionList(options);
			options = tempOptions;
		}
		
		if (bEncrypt && !bSign)
			LoadString(hInst, IDS_WORKINGENCRYPT, szWorkingTitle, 
				sizeof(szWorkingTitle));
		else if (!bEncrypt && bSign)
			LoadString(hInst, IDS_WORKINGSIGN, szWorkingTitle, 
				sizeof(szWorkingTitle));
		else
			LoadString(hInst, IDS_WORKINGENCRYPTSIGN, szWorkingTitle, 
				sizeof(szWorkingTitle));

		hwndWorking = WorkingDlgProcThread(GetModuleHandle(szModule), 
						hInst, NULL, szWorkingTitle, "");

		if (*pSignOptions == NULL)
			PGPBuildOptionList(context, pSignOptions, 
				PGPOLastOption(context));

		err = PGPEncode(context,
				ioOptions,
				PGPOEventHandler(context, EncodeEventHandler, hwndWorking),
				options,
				encryptOptions,
				*pSignOptions,
				PGPOSendNullEvents(context, 100),
				PGPODataIsASCII(context, (PGPBoolean) !bBinary),
				PGPOVersionString(context, pgpVersionHeaderString),
				PGPOAskUserForEntropy(context, TRUE),
				PGPOForYourEyesOnly(context,
					(PGPBoolean)((prds->dwOptions & PGPCL_FYEO)==PGPCL_FYEO)),
				PGPOLastOption(context));

		DestroyWindow(hwndWorking);

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

		if (err == kPGPError_BadPassphrase)
		{
			if (encryptOptions != NULL)
			{
				PGPFreeOptionList(encryptOptions);
				encryptOptions = NULL;
			}

			PGPFreeOptionList(*pSignOptions);
			*pSignOptions = NULL;
		}
	}

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

	if (IsntPGPError(err))
	{
		if (*pSignOptions == NULL)
			PGPBuildOptionList(context, pSignOptions, 
				PGPOLastOption(context));

		PGPBuildOptionList(context, &tempOptions, 
			*pSignOptions,
			encryptOptions,
			PGPOLastOption(context));

		PGPFreeOptionList(*pSignOptions);
		PGPFreeOptionList(encryptOptions);
		*pSignOptions = tempOptions;
		encryptOptions = NULL;
	}

EncryptSignError:

	if (szPassphrase != NULL)
	{
		PGPclFreeCachedPhrase(szPassphrase);
		szPassphrase = NULL;
	}

	if (pPasskey != NULL)
	{
		PGPFreeData(pPasskey);
		pPasskey = NULL;
	}

	if (szConvPass != NULL)
	{
		PGPclFreePhrase(szConvPass);
		szConvPass = NULL;
	}

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

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

	return err;
}


PGPError EncodeEventHandler(PGPContextRef context, 
							PGPEvent *event, 
							PGPUserValue userValue)
{
	HWND			hwnd			= NULL;
	PGPError		err				= kPGPError_NoErr;

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

	hwnd = (HWND) userValue;

	switch (event->type)
	{
	case kPGPEvent_EntropyEvent:
		err = PGPclRandom(context, hwnd, 
				event->data.entropyData.entropyBitsNeeded);
		break;

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

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

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

	return err;
}


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

	PGPclEncDecErrorToString(nCode, szErrorMsg, 254);

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

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


/*__Editor_settings____

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