clcache.c

vc环境下的pgp源码

				sSetCacheDuration (&cacheDecryption, uCacheSecs);

				// start thread to purge cache after delay
				if (!cacheDecryption.bCacheActive) {
					cacheDecryption.bCacheActive = TRUE;
					_beginthreadex (NULL, 0, 
						(LPTHREAD_START_ROUTINE)sClearDecryptionCacheThread, 
						0, 0, &dw);
				}
			}
			else
				sEmptyCache (&cacheDecryption);
		}

		// problem (cancel or other error) -- flush cache
		else {
			sEmptyCache (&cacheDecryption);
			sSetCacheDuration (&cacheDecryption, 0);

			if (err == kPGPError_NoErr) 
				err = kPGPError_UserAbort;
		}
	}

	LeaveCriticalSection (&criticalSectionCache);

//	MessageBox(hwnd,*pszBuffer,"Passphrase",MB_OK);

	return err;
}

//_____________________________________________________
//
//	PGPGetCachedSigningPhrase
//	This routine is called to get either signing cached phrase 
//	(if available) or prompt user for phrase.
//

PGPError PGPclExport
PGPclGetCachedSigningPhrase (
		PGPContextRef		context, 
		PGPtlsContextRef	tlsContext,
		HWND				hwnd,
		LPSTR				szPrompt,
		BOOL				bForceUserInput, 
		LPSTR*				pszBuffer, 
		PGPKeySetRef		keysetSigning,
		PGPKeyRef*			pkeySigning,
		PGPHashAlgorithm*	pulHashAlg,
		UINT*				puOptions, 
		UINT				uFlags,
		PGPByte**			ppPasskeyBuffer,
		PGPUInt32*			piPasskeyLength,
		PGPKeySetRef*		pkeysetAdded,
		char *				szTitle)
{
	PGPBoolean		bCacheEnabled	= FALSE;
	PGPUInt32		uCacheSecs		= 0;
	PGPError		err				= kPGPError_NoErr;
	PGPBoolean		bWarnRSADSA		= FALSE;
	BOOL			bAskUser		= TRUE;
	PGPSize			size;
	PGPPrefRef		prefref;
	PGPKeyID		keyid;
	DWORD			dw;

	// Get needed preferences
	err = PGPclOpenClientPrefs (PGPGetContextMemoryMgr (context), &prefref);
	if (IsntPGPError (err))
	{
		PGPGetPrefBoolean (prefref, kPGPPrefSignCacheEnable, &bCacheEnabled);
		PGPGetPrefNumber (prefref, kPGPPrefSignCacheSeconds, &uCacheSecs);
		// Need a never show again box?
		PGPGetPrefBoolean (prefref, 
					kPGPPrefWarnOnRSARecipAndNonRSASigner, &bWarnRSADSA);
		PGPclCloseClientPrefs (prefref, FALSE);
	}

	EnterCriticalSection (&criticalSectionCache);

	// use phrase from cache
	if (!bForceUserInput && 
		bCacheEnabled && 
		sIsCacheValid (&cacheSigning)) 
	{
		err = kPGPError_NoErr;

		if (bWarnRSADSA && 
			(cacheSigning.CachedKeyAlg != kPGPPublicKeyAlgorithm_RSA) && 
			(uFlags & PGPCL_RSAENCRYPT)) 
		{
			PGPBoolean bNeverShowAgain	= FALSE;

			err = PGPclRSADSAMixWarning (hwnd, &bNeverShowAgain);

			switch (err) {
			case kPGPError_NoErr :
				bAskUser = TRUE;
				if (bNeverShowAgain) {
					err = PGPclOpenClientPrefs (
								PGPGetContextMemoryMgr (context), &prefref);
					if (IsntPGPError (err))
					{
						PGPSetPrefBoolean (prefref, 
							kPGPPrefWarnOnRSARecipAndNonRSASigner, FALSE);
						PGPclCloseClientPrefs (prefref, TRUE);
					}
				}
				break;

			case kPGPError_UserAbort :
				bAskUser = FALSE;
				break;
			}
		}

		if (err == kPGPError_NoErr) {
			// reset cache duration
			sSetCacheDuration (&cacheSigning, uCacheSecs);

			// see if cached key is in keyset
			if (pkeySigning) {
				err = PGPImportKeyID (&cacheSigning.CachedKeyID, &keyid);
				if (IsntPGPError (err)) {

					// if so, get keyref for this keyid
					err = PGPGetKeyByKeyID (keysetSigning, &keyid, 
								kPGPPublicKeyAlgorithm_Invalid, pkeySigning);
					if (IsPGPError (err)) 
						*pkeySigning = NULL;
				}

				err = sCopyCache (&cacheSigning, context, pszBuffer, 
										ppPasskeyBuffer, piPasskeyLength);

				if (pulHashAlg) 
					*pulHashAlg = cacheSigning.CachedHashAlg;
				if (puOptions) 
					*puOptions = cacheSigning.uCachedOptions;

				bAskUser = FALSE;
			}
		}
	}

	// otherwise, get phrase from user
	if (bAskUser) 
	{
		sEmptyCache (&cacheSigning);

		// call PGPcl routine to post passphrase dialog
		err = PGPclGetPhrase (context, keysetSigning, hwnd, szPrompt, 
									 &cacheSigning.pszCachedPassphrase, 
									 NULL, NULL, 0, pkeySigning, puOptions, 
									 uFlags,
									 &cacheSigning.pCachedPasskey,
									 &cacheSigning.iCachedPasskeyLength,
									 0, 0, tlsContext, pkeysetAdded,szTitle);

		// user entered phrase -- setup cache
		if ((err == kPGPError_NoErr) && 
			(cacheSigning.pszCachedPassphrase || 
						cacheSigning.pCachedPasskey)) 
		{
			// scramble cache contents
			sScrambleCache (&cacheSigning);

			if (bCacheEnabled) {
				sSetCacheDuration (&cacheSigning, uCacheSecs);

				if (!cacheSigning.bCacheActive) {
					cacheSigning.bCacheActive = TRUE;
					_beginthreadex (NULL, 0, 
						(LPTHREAD_START_ROUTINE)sClearSigningCacheThread, 
						0, 0, &dw);
				}
			}

			// copy to caller's buffers
			err = sCopyCache (&cacheSigning, context, pszBuffer, 
								ppPasskeyBuffer, piPasskeyLength);

			PGPGetHashAlgUsed (*pkeySigning, &cacheSigning.CachedHashAlg);
			if (pulHashAlg) 
				*pulHashAlg = cacheSigning.CachedHashAlg;

			if (bCacheEnabled) {
				if (puOptions) 
					cacheSigning.uCachedOptions = *puOptions;
				else 
					cacheSigning.uCachedOptions = 0;

				PGPGetKeyIDFromKey (*pkeySigning, &keyid);
				PGPExportKeyID (&keyid, 
									cacheSigning.CachedKeyID, &size);

				PGPGetKeyNumber (*pkeySigning, 
					kPGPKeyPropAlgID, &cacheSigning.CachedKeyAlg);
			}
			else 
			{
				sEmptyCache (&cacheSigning);
			}
		}

		// problem (cancel or other error) -- flush cache
		else {
			sEmptyCache (&cacheSigning);
			sSetCacheDuration (&cacheSigning, 0);

			if (err == kPGPError_NoErr)
				err = kPGPError_UserAbort;
		}
	}

	LeaveCriticalSection (&criticalSectionCache);

	return err;
}

//	___________________________________________________
//
//	Broadcast purge message

VOID PGPclExport 
PGPclNotifyPurgePassphraseCache (
		WPARAM wParam,
		LPARAM lParam)
{
	UINT uMessageID;

	uMessageID = RegisterWindowMessage (PURGEPASSPHRASECACEHMSG);
	PostMessage (HWND_BROADCAST, uMessageID, wParam, lParam);
}

//___________________________________
//
//	PGPPurgeCachedDecryptionPhrase
//	Called to purge phrase from cache.

BOOL PGPclExport
PGPclPurgeCachedPassphrase (DWORD dwFlags) 
{
	BOOL	bReturn		= FALSE;

	EnterCriticalSection (&criticalSectionCache);

	if (dwFlags & PGPCL_DECRYPTIONCACHE) {
		sEmptyCache (&cacheDecryption);
		sSetCacheDuration (&cacheDecryption, 0);
		bReturn |= cacheDecryption.bCacheActive;
	}

	if (dwFlags & PGPCL_SIGNINGCACHE) {
		sEmptyCache (&cacheSigning);
		sSetCacheDuration (&cacheSigning, 0);
		bReturn |= cacheSigning.bCacheActive;
	}

	LeaveCriticalSection (&criticalSectionCache);

	return bReturn;
}

//________________________________________________
//
//	PGPFreeCachedPhrase
//	Called to wipe and free the phrase returned by
//	PGPGetCachedPhrase.

VOID PGPclExport
PGPclFreeCachedPhrase (LPSTR szPhrase) 
{
	pgpClearMemory (szPhrase, lstrlen (szPhrase));
	secFree (szPhrase);
}

//_________________________________________________________
//
//	PGPQueryDecryptCacheSecsRemaining
//	Returns number of seconds remaining until cache expires

INT PGPclExport 
PGPclQueryDecryptionCacheSecsRemaining (VOID) 
{
	return (cacheDecryption.iCacheCounter);	
}

//_________________________________________________________
//
//	PGPQuerySignCacheSecsRemaining
//	Returns number of seconds remaining until cache expires

INT PGPclExport
PGPclQuerySigningCacheSecsRemaining (VOID) 
{
	return (cacheSigning.iCacheCounter);	
}


//_____________________________________________________
//

VOID
PGPInitPassphraseCaches (PGPContextRef context)
{
	if (!bScramblerInitialized) {
		PGPContextGetRandomBytes (context, 
							szScrambler, sizeof(szScrambler));
		bScramblerInitialized = TRUE;
	}

	pgpClearMemory (&cacheDecryption, sizeof(CACHE));
	pgpClearMemory (&cacheSigning, sizeof(CACHE));


	InitializeCriticalSection (&criticalSectionCache);
}

//_____________________________________________________
//

VOID
PGPClosePassphraseCaches (VOID)
{
	while (
		PGPclPurgeCachedPassphrase (
			PGPCL_DECRYPTIONCACHE|PGPCL_SIGNINGCACHE)) 
	{
		Sleep (200);
	}

	pgpClearMemory (&cacheDecryption, sizeof(CACHE));
	pgpClearMemory (&cacheSigning, sizeof(CACHE));
	DeleteCriticalSection (&criticalSectionCache);
}