clmisc.c

vc环境下的pgp源码

//	___________________________________________________
//
//	set keyring and randseed file paths using SDK 

PGPError PGPclExport 
PGPclSetSDKFilePaths (
		LPSTR	pszPubRingPath,
		LPSTR	pszPrivRingPath,
		LPSTR	pszRandSeedPath,
		BOOL	bCreateFiles)
{
	PGPKeySetRef	keysetDummy		= kInvalidPGPKeySetRef;
	PGPFileSpecRef	fileref			= kInvalidPGPFileSpecRef;
	PGPContextRef	context			= kInvalidPGPContextRef;
	PGPError		err				= kPGPError_NoErr;

	err = PGPNewContext (kPGPsdkAPIVersion, &context);
	PGPsdkLoadDefaultPrefs (context);

	if (IsntPGPError (err)) {
	
		if (pszPubRingPath) {
			err = PGPNewFileSpecFromFullPath (context, 
									pszPubRingPath, &fileref); CKERR;
			if (PGPFileSpecRefIsValid (fileref)) {
				err = PGPsdkPrefSetFileSpec (context, 
								kPGPsdkPref_PublicKeyring, fileref);
				PGPFreeFileSpec (fileref);
				fileref = kInvalidPGPFileSpecRef;
			}
		} CKERR;

		if (pszPrivRingPath) {
			err = PGPNewFileSpecFromFullPath (context, 
									pszPrivRingPath, &fileref); CKERR;
			if (PGPFileSpecRefIsValid (fileref)) {
				err = PGPsdkPrefSetFileSpec (context, 
								kPGPsdkPref_PrivateKeyring, fileref);
				PGPFreeFileSpec (fileref);
				fileref = kInvalidPGPFileSpecRef;
			}
		} CKERR;

		if (pszRandSeedPath) {
			err = PGPNewFileSpecFromFullPath (context, 
									pszRandSeedPath, &fileref); CKERR;
			if (PGPFileSpecRefIsValid (fileref)) {
				err = PGPsdkPrefSetFileSpec (context, 
								kPGPsdkPref_RandomSeedFile, fileref);
				PGPFreeFileSpec (fileref);
				fileref = kInvalidPGPFileSpecRef;
			}
		} CKERR;

		PGPsdkSavePrefs (context);
		sSavePGPnetSDKPrefsFile (context);

		if (IsntPGPError (err) && bCreateFiles) {
			err = PGPOpenDefaultKeyRings (context, 
				kPGPKeyRingOpenFlags_Create|kPGPKeyRingOpenFlags_Mutable, 
				&keysetDummy);
			if (PGPKeySetRefIsValid (keysetDummy))
				PGPFreeKeySet (keysetDummy);
		}
	}
done :
	if (PGPFileSpecRefIsValid (fileref)) 
		PGPFreeFileSpec (fileref);
	if (PGPContextRefIsValid (context))
		PGPFreeContext (context);

	return err;
}


//	__________________________________________________
//
//	save user information to preferences file 

PGPError PGPclExport 
PGPclSetUserInfo (
		LPSTR	szOwnerName,
		LPSTR	szCompanyName,
		LPSTR	szLicenseNumber)
{
	PGPError		err;
	PGPPrefRef		prefref;
	PGPContextRef	context;

	err = PGPNewContext (kPGPsdkAPIVersion, &context);
	if (IsPGPError (err)) return err;

	err = PGPclOpenClientPrefs (PGPGetContextMemoryMgr (context), &prefref);
	if (IsPGPError (err)) {
		PGPFreeContext (context);
		return err;
	}

	if (szOwnerName) {
		PGPSetPrefString (prefref, kPGPPrefOwnerName, szOwnerName);
	}

	if (szCompanyName) {
		PGPSetPrefString (prefref, kPGPPrefCompanyName, szCompanyName);
	}

#if (PGP_NO_LICENSE_NUMBER == 0)
	if (szLicenseNumber) {
		PGPSetPrefString (prefref, kPGPPrefLicenseNumber, szLicenseNumber);
	}
#endif //PGP_NO_LICENSE_NUMBER

	err = PGPclCloseClientPrefs (prefref, TRUE);

	PGPFreeContext (context);
	return err;
}


//	_________________________________________________
//
//	Wrapper routine for platform independent 
//	word wrap code.

PGPError PGPclExport 
PGPclWrapBuffer (
		LPSTR		szInText,
		PGPUInt16	wrapColumn,
		LPSTR*		pszOutText)
{
	PGPError		err				= kPGPError_NoErr;
	PGPIORef		inRef, outRef;
	PGPMemoryMgrRef	memMgr;
	PGPFileOffset	outSize;
	PGPSize			outRead;
	INT				InSize;

	outRead = 0;

	err = PGPNewMemoryMgr ( 0, &memMgr);

	if (IsntPGPError (err))
	{
		PGPNewMemoryIO (
			memMgr,
			(PGPMemoryIORef *)(&inRef));

		InSize = strlen (szInText);
		PGPIOWrite (inRef,
			InSize,
			szInText);
		PGPIOFlush (inRef);
		PGPIOSetPos (inRef,0);

		PGPNewMemoryIO (
			memMgr,
			(PGPMemoryIORef *)(&outRef));

		err = pgpWordWrapIO(
			  inRef,outRef,
			  wrapColumn,
			  "\r\n");

		if (IsntPGPError (err))
		{
			INT memamt;

			PGPIOGetPos (outRef, &outSize);

			memamt = (INT)outSize+1;
			*pszOutText = (CHAR *)malloc (memamt);

			if (*pszOutText)
			{
				memset (*pszOutText, 0x00, memamt);

				PGPIOSetPos (outRef,0);
				PGPIORead (outRef,
					(INT)outSize,
					*pszOutText, 
					&outRead);
				PGPIOFlush (outRef);
			}
			else err = kPGPError_OutOfMemory;
		}
		PGPFreeIO (inRef); 
		PGPFreeIO (outRef);
	}
	PGPFreeMemoryMgr (memMgr);

	return err;
}

//	__________________________________________________
//
//	free previously-wrapped buffer

PGPError PGPclExport 
PGPclFreeWrapBuffer (LPSTR textBuffer)
{
	memset (textBuffer, 0x00, lstrlen (textBuffer));
	free (textBuffer);

	return kPGPError_NoErr;
}

//	________________________
//
//	Get keyid string from key

PGPError PGPclExport 
PGPclGetKeyFromKeyID (
		PGPContextRef	context,
		PGPKeySetRef	keyset,
		LPSTR			szID,
		UINT			uAlg,
		PGPKeyRef*		pkey) 
{
	PGPError		err; 
	PGPKeyID		keyID;

	err = PGPImportKeyID (szID, &keyID);
	if (IsntPGPError (err)) {
		err = PGPGetKeyByKeyID (keyset, &keyID, uAlg, pkey);
		if (!(*pkey)) 
			err = kPGPError_ItemNotFound;
	}

	return err;
}

//	________________________
//
//	find out if SDK supports the specified public key algorithm

PGPError PGPclExport 
PGPclCheckSDKSupportForPKAlg (
		PGPPublicKeyAlgorithm alg,
		PGPBoolean mustEncrypt,
		PGPBoolean mustSign)
{
	PGPError	err			= kPGPError_FeatureNotAvailable;

	PGPUInt32					i, iNumAlgs;
	PGPPublicKeyAlgorithmInfo	alginfo;

	err = PGPCountPublicKeyAlgorithms (&iNumAlgs);
	if (IsPGPError (err)) return kPGPError_FeatureNotAvailable;

	for (i=0; i<iNumAlgs; i++) {
		err = PGPGetIndexedPublicKeyAlgorithmInfo (i, &alginfo);
		if (IsntPGPError (err)) {
			if (alginfo.algID == alg) {
				err = kPGPError_NoErr;
				if (mustEncrypt && !(alginfo.canEncrypt))
					err = kPGPError_FeatureNotAvailable;
				if (mustSign && !(alginfo.canSign))
					err = kPGPError_FeatureNotAvailable;
				return err;
			}
		}
	}

	return kPGPError_FeatureNotAvailable;
}

//	________________________
//
//	find out if SDK supports the specified cipher algorithm

PGPError PGPclExport 
PGPclCheckSDKSupportForCipherAlg (PGPCipherAlgorithm alg)
{
	PGPError	err		= kPGPError_FeatureNotAvailable;

	PGPUInt32					i, iNumAlgs;
	PGPSymmetricCipherInfo		cipherinfo;

	err = PGPCountSymmetricCiphers (&iNumAlgs);
	if (IsPGPError (err)) return kPGPError_FeatureNotAvailable;

	for (i=0; i<iNumAlgs; i++) {
		err = PGPGetIndexedSymmetricCipherInfo (i, &cipherinfo);
		if (IsntPGPError (err)) {
			if (cipherinfo.algID == alg) {
				return kPGPError_NoErr;
			}
		}
	}

	return kPGPError_FeatureNotAvailable;
}

//	________________________
//
//	sync up keysets to resolve trust information

PGPError PGPclExport 
PGPclSyncKeySets (
		PGPContextRef context,
		PGPKeySetRef keysetMain,
		PGPKeySetRef keysetNew)
{

	PGPKeySetRef	keysetCombined;
	PGPKeySetRef	keysetSync;
	PGPError		err;

	if (!PGPRefIsValid (keysetNew)) return kPGPError_NoErr;

	if (!PGPRefIsValid (keysetMain)) {
		PGPsdkLoadDefaultPrefs (context);
		err = PGPOpenDefaultKeyRings (context, 0, &keysetSync);
		if (IsPGPError (err) || !PGPRefIsValid (keysetSync)) return err;
	}
	else keysetSync = keysetMain;

	err = PGPNewKeySet (context, &keysetCombined);
	if (IsntPGPError (err)) {

		err = PGPAddKeys (keysetNew, keysetCombined);
		if (IsntPGPError (err)) {

			err = PGPAddKeys (keysetSync, keysetCombined);
			if (IsntPGPError (err)) {

				err = PGPCheckKeyRingSigs (keysetNew, 
									keysetCombined, FALSE, NULL, 0);

				if (IsntPGPError (err)) {
					err = PGPPropagateTrust (keysetCombined);
				}
			}
		}

		PGPFreeKeySet (keysetCombined);
	}

	if (!PGPRefIsValid (keysetMain)) PGPFreeKeySet (keysetSync);

	return err;
}

//	__________________________________________________________
//
//  Check to see if it's time to auto-update keys

PGPError PGPclExport
PGPclCheckAutoUpdate(PGPMemoryMgrRef memoryMgr, 
					 PGPBoolean  bResetDates,
					 PGPBoolean* pbUpdateAllKeys,
					 PGPBoolean* pbUpdateTrustedIntroducers,
					 PGPBoolean* pbUpdateCRL)
{
	PGPError	err = kPGPError_NoErr;

#if PGP_BUSINESS_SECURITY
	PGPPrefRef	prefsAdmin			= kInvalidPGPPrefRef;
	PGPPrefRef	prefsClient			= kInvalidPGPPrefRef;

	PGPBoolean	bUpdateAllKeys;
	PGPBoolean	bUpdateTrustedIntroducers;
	PGPBoolean	bUpdateCRLs;
	PGPInt32	nDaysUpdateAllKeys;
	PGPInt32	nDaysUpdateTrustedIntroducers;
	PGPUInt32	nLastUpdate;
	PGPUInt32	nNextUpdate;
	time_t		tToday;
	time_t		tLastUpdate;
	struct tm 	tmToday;
	struct tm 	tmLastUpdate;
#endif //PGP_BUSINESS_SECURITY

	if (pbUpdateAllKeys != NULL)
		*pbUpdateAllKeys = FALSE;

	if (pbUpdateTrustedIntroducers != NULL)
		*pbUpdateTrustedIntroducers = FALSE;

	if (pbUpdateCRL != NULL)
		*pbUpdateCRL = FALSE;

#if PGP_BUSINESS_SECURITY

	err = PGPclOpenAdminPrefs (memoryMgr, 
				&prefsAdmin, PGPclIsAdminInstall()); CKERR;
	err = PGPclOpenClientPrefs (memoryMgr, &prefsClient); CKERR;

	tToday = PGPGetStdTimeFromPGPTime (PGPGetTime());
	memcpy (&tmToday, localtime(&tToday), sizeof(struct tm));

	err = PGPGetPrefBoolean (prefsAdmin, 
				kPGPPrefUpdateAllKeys, &bUpdateAllKeys);
	if (IsPGPError (err))
	{
		bUpdateAllKeys = FALSE;
		err = kPGPError_NoErr;
	}

	err = PGPGetPrefBoolean (prefsAdmin, 
				kPGPPrefUpdateTrustedIntroducers, &bUpdateTrustedIntroducers);
	if (IsPGPError (err))
	{
		bUpdateTrustedIntroducers = FALSE;
		err = kPGPError_NoErr;
	}

	err = PGPGetPrefBoolean (prefsAdmin, 
				kPGPPrefAutoUpdateX509CRL, &bUpdateCRLs);
	if (IsPGPError (err))
	{
		bUpdateCRLs = FALSE;
		err = kPGPError_NoErr;
	}
///>>>
	bUpdateCRLs = FALSE;
///<<<

	if (bUpdateAllKeys)
	{
		err = PGPGetPrefNumber (prefsAdmin, kPGPPrefDaysUpdateAllKeys,
				&nDaysUpdateAllKeys);
		if (IsPGPError (err))
		{
			nDaysUpdateAllKeys = 0;
			err = kPGPError_NoErr;
		}

		if (nDaysUpdateAllKeys > 0)
		{
			err = PGPGetPrefNumber (prefsClient, kPGPPrefLastAllKeysUpdate,
					&nLastUpdate);
			if (IsPGPError(err))
			{
				nLastUpdate = 0;
				err = kPGPError_NoErr;
			}

			tLastUpdate = PGPGetStdTimeFromPGPTime (nLastUpdate);
			memcpy (&tmLastUpdate, localtime (&tLastUpdate), 
						sizeof(struct tm));

			if (tmToday.tm_year > tmLastUpdate.tm_year)
				tmToday.tm_yday += 366;

			if ((tmToday.tm_yday - tmLastUpdate.tm_yday) >=
				nDaysUpdateAllKeys)
			{
				*pbUpdateAllKeys = TRUE;
				if (bResetDates)
				{
					PGPSetPrefNumber (prefsClient, kPGPPrefLastAllKeysUpdate,
						PGPGetTime());
				}
			}
		}
	}

	if (bUpdateTrustedIntroducers)
	{
		err = PGPGetPrefNumber (prefsAdmin, 
				kPGPPrefDaysUpdateTrustedIntroducers,
				&nDaysUpdateTrustedIntroducers);
		if (IsPGPError(err))
		{
			nDaysUpdateTrustedIntroducers = 0;
			err = kPGPError_NoErr;
		}

		if (nDaysUpdateTrustedIntroducers > 0)
		{
			err = PGPGetPrefNumber (prefsClient, 
					kPGPPrefLastTrustedIntroducersUpdate,
					&nLastUpdate);
			if (IsPGPError(err))
			{
				nLastUpdate = 0;
				err = kPGPError_NoErr;
			}

			tLastUpdate = PGPGetStdTimeFromPGPTime (nLastUpdate);
			memcpy (&tmLastUpdate, localtime (&tLastUpdate), 
						sizeof(struct tm));

			if (tmToday.tm_year > tmLastUpdate.tm_year)
				tmToday.tm_yday += 366;

			if ((tmToday.tm_yday - tmLastUpdate.tm_yday) >=
				nDaysUpdateTrustedIntroducers)
			{
				*pbUpdateTrustedIntroducers = TRUE;
				if (bResetDates) 
				{
					PGPSetPrefNumber (prefsClient, 
						kPGPPrefLastTrustedIntroducersUpdate,
						PGPGetTime());
				}
			}
		}
	}

	if (bUpdateCRLs)
	{
		err = PGPGetPrefNumber (prefsClient, 
				kPGPPrefNextAutoCRLUpdate, &nNextUpdate);

		if (nNextUpdate > 0)
		{
			if (nNextUpdate <= PGPGetTime ())
				*pbUpdateCRL = TRUE;
			if (bResetDates)
			{
				PGPSetPrefNumber (prefsClient, 
					kPGPPrefNextAutoCRLUpdate,
					0);
			}
		}
	}

done:
	if (PGPPrefRefIsValid (prefsClient))