pgpshare.c

vc环境下的pgp源码

	*splitShares = newShare;
	return err;
}


/* The share objects being combined are NOT freed by this function */
PGPError PGPCombineShares(PGPShareRef firstShare, PGPShareRef secondShare,
				PGPShareRef *combinedShares)
{
	PGPShareRef	newShare = NULL;
	PGPSize		shareSize = 0;
	PGPSize		dataSize = 0;
	PGPError	err = kPGPError_NoErr;

	if (IsntNull(combinedShares))
		*combinedShares = NULL;

	PGPValidateParam(PGPShareRefIsValid(firstShare));
	PGPValidateParam(PGPShareRefIsValid(secondShare));
	PGPValidatePtr(combinedShares);

	if (PGPCompareKeyIDs(&(firstShare->keyID), &(secondShare->keyID)) != 0)
		return kPGPClientError_DifferentSplitKeys;

	if (PGPCompareShareIDs(firstShare->shareID, secondShare->shareID) != 0)
		return kPGPClientError_DifferentSharePool;

	if (firstShare->threshold != secondShare->threshold)
		return kPGPClientError_DifferentSharePool;

	if (firstShare->totalShares != secondShare->totalShares)
		return kPGPClientError_DifferentSharePool;

	if (IsSamePGPShares(firstShare, secondShare))
		return kPGPClientError_IdenticalShares;

	newShare = (PGPShareRef) PGPNewData(firstShare->memoryMgr, 
								sizeof(PGPShare), 
								kPGPMemoryMgrFlags_Clear);

	pgpAssert(IsntNull(newShare));
	if (IsNull(newShare))
		return kPGPError_OutOfMemory;

	newShare->context		= firstShare->context;
	newShare->memoryMgr		= firstShare->memoryMgr;
	newShare->threshold		= firstShare->threshold;
	newShare->numShares		= firstShare->numShares + secondShare->numShares;
	newShare->totalShares	= firstShare->totalShares;
	newShare->shareDataSize = firstShare->shareDataSize +
								secondShare->shareDataSize;

	pgpCopyMemory(&(firstShare->keyID), &(newShare->keyID), sizeof(PGPKeyID));
	pgpCopyMemory(&(firstShare->shareID), &(newShare->shareID), 
		sizeof(PGPShareID));

	newShare->shareData	= (PGPByte *) PGPNewSecureData(firstShare->memoryMgr, 
											newShare->shareDataSize, 
											kPGPMemoryMgrFlags_Clear);

	if (IsNull(newShare->shareData))
		err = kPGPError_OutOfMemory;

	if (IsntPGPError(err))
	{
		pgpCopyMemory(firstShare->shareData, newShare->shareData, 
			firstShare->shareDataSize);

		pgpCopyMemory(secondShare->shareData, 
			&(newShare->shareData[firstShare->shareDataSize]),
			secondShare->shareDataSize);
	}

	if (IsntPGPError(err))
		err = sCalculateShareHash(newShare);

	if (IsPGPError(err))
	{
		PGPFreeShares(newShare);
		newShare = NULL;
	}

	*combinedShares = newShare;
	return err;
}


PGPError PGPFreeShares(PGPShareRef share)
{
	PGPError err = kPGPError_NoErr;

	PGPValidateParam(PGPShareRefIsValid(share));

	if (IsntNull(share->shareData))
		PGPFreeData(share->shareData);

	if (IsntNull(share->shareHash))
		PGPFreeData(share->shareHash);

	PGPFreeData(share);
	return err;
}


PGPError PGPGetKeyIDFromShares(PGPShareRef share, PGPKeyID *id)
{
	PGPError err = kPGPError_NoErr;

	PGPValidateParam(PGPShareRefIsValid(share));
	PGPValidatePtr(id);

	pgpCopyMemory(&(share->keyID), id, sizeof(PGPKeyID));

	return err;
}


PGPError PGPGetShareID(PGPShareRef share, PGPShareID *id)
{
	PGPError err = kPGPError_NoErr;

	PGPValidateParam(PGPShareRefIsValid(share));
	PGPValidatePtr(id);

	pgpCopyMemory(&(share->shareID), id, sizeof(PGPShareID));

	return err;
}


PGPBoolean IsSamePGPShares(PGPShareRef firstShare, PGPShareRef secondShare)
{
	PGPBoolean	result = FALSE;
	PGPSize		index1;
	PGPSize		index2;
	PGPSize		shareSize;

	if (!PGPShareRefIsValid(firstShare))
		return FALSE;
	if (!PGPShareRefIsValid(secondShare))
		return FALSE;

	shareSize = firstShare->shareDataSize / firstShare->numShares;
	if (shareSize != (secondShare->shareDataSize / secondShare->numShares))
		return FALSE;

	if ((firstShare->numShares == secondShare->numShares) &&
		(firstShare->shareHashSize == secondShare->shareHashSize))
	{
		result = pgpMemoryEqual(firstShare->shareHash, 
					secondShare->shareHash, firstShare->shareHashSize);
	}

	if (result == FALSE)
	{
		for (index1=0; index1<firstShare->numShares; index1++)
			for (index2=0; index2<secondShare->numShares; index2++)
				if (pgpMemoryEqual(&(firstShare->shareData[index1*shareSize]),
						&(secondShare->shareData[index2*shareSize]),
						shareSize))
				{
					result = TRUE;
					index1 = firstShare->numShares;
					index2 = secondShare->numShares;
				}
	}

	return result;
}


/* The share data needs to be freed with PGPFreeData(shareData) */
PGPError pgpGetShareData(PGPShareRef share, PGPByte **shareData, 
				PGPSize *shareDataSize)
{
	PGPError	err = kPGPError_NoErr;

	if (IsntNull(shareData))
		*shareData = NULL;

	if (IsntNull(shareDataSize))
		*shareDataSize = 0;

	PGPValidateParam(PGPShareRefIsValid(share));
	PGPValidatePtr(shareData);
	PGPValidatePtr(shareDataSize);

	*shareData = (PGPByte *) PGPNewSecureData(share->memoryMgr, 
								share->shareDataSize, 
								kPGPMemoryMgrFlags_Clear);

	if (IsNull(*shareData))
		err = kPGPError_OutOfMemory;
	else
	{
		pgpCopyMemory(share->shareData, *shareData, share->shareDataSize);
		*shareDataSize = share->shareDataSize;
	}
	
	return err;
}


/* The share hash needs to be freed with PGPFreeData(shareHash) */
PGPError pgpGetShareHash(PGPShareRef share, PGPByte **shareHash, 
				PGPSize *shareHashSize)
{
	PGPError	err = kPGPError_NoErr;

	if (IsntNull(shareHash))
		*shareHash = NULL;

	if (IsntNull(shareHashSize))
		*shareHashSize = 0;

	PGPValidateParam(PGPShareRefIsValid(share));
	PGPValidatePtr(shareHash);
	PGPValidatePtr(shareHashSize);

	*shareHash = (PGPByte *) PGPNewData(share->memoryMgr, 
								share->shareHashSize, 
								kPGPMemoryMgrFlags_Clear);

	if (IsNull(*shareHash))
		err = kPGPError_OutOfMemory;
	else
	{
		pgpCopyMemory(share->shareHash, *shareHash, share->shareHashSize);
		*shareHashSize = share->shareHashSize;
	}
	
	return err;
}


PGPUInt32 PGPGetShareThreshold(PGPShareRef share)
{
	if (PGPShareRefIsValid(share))
		return share->threshold;
	else
		return 0;
}


/* This is the number of shares contained in the share object */
PGPUInt32 PGPGetNumberOfShares(PGPShareRef share)
{
	if (PGPShareRefIsValid(share))
		return share->numShares;
	else
		return 0;
}


/* The share object may contain less than the total number of shares */
PGPUInt32 PGPGetTotalNumberOfShares(PGPShareRef share)
{
	if (PGPShareRefIsValid(share))
		return share->totalShares;
	else
		return 0;
}


PGPInt32 PGPCompareShareIDs(PGPShareID firstID, PGPShareID secondID)
{
	PGPInt32 index;
	PGPInt32 result = 0;

	for (index=sizeof(firstID.data)-1; index>=0; index--)
	{
		if (firstID.data[index] < secondID.data[index])
		{
			result = -1;
			index = -1;
		}
		else if (firstID.data[index] > secondID.data[index])
		{
			result = 1;
			index = -1;
		}
	}

	return result;
}


static PGPError sCalculateShareHash(PGPShareRef share)
{
	PGPHashContextRef	hash = NULL;
	PGPByte				nullByte = 0;
	PGPError			err = kPGPError_NoErr;

	err = PGPNewHashContext(share->memoryMgr, kPGPHashAlgorithm_SHA, &hash);

	if (IsntPGPError(err))
	{
		PGPGetHashSize(hash, &(share->shareHashSize));

		share->shareHash = (PGPByte *) PGPNewData(share->memoryMgr,
											share->shareHashSize,
											kPGPMemoryMgrFlags_Clear);
	}

	if (IsNull(share->shareHash))
		err = kPGPError_OutOfMemory;

	if (IsntPGPError(err))
	{
		if (IsntNull(share->shareData))
			PGPContinueHash(hash, share->shareData, share->shareDataSize);
		else
			PGPContinueHash(hash, &nullByte, sizeof(nullByte));

		PGPFinalizeHash(hash, share->shareHash);
	}

	if (IsntNull(hash))
		PGPFreeHashContext(hash);

	return err;
}


/*__Editor_settings____

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