pgpkeyfilter.c

vc环境下的pgp源码

	PGPUInt32			val,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeUserIDNumber, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.propnum.prop = prop;
		(*outFilter)->value.propnum.val = val;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

#if 0
/* Add support for this when we have userid time properties */
	PGPError
PGPNewUserIDTimeFilter(
	PGPContextRef		context,
	PGPUserIDPropName	prop,
	PGPTime				val,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeUserIDTime, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.proptime.prop = prop;
		(*outFilter)->value.proptime.val = val;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}
#endif

	PGPError
PGPNewUserIDStringBufferFilter(
	PGPContextRef		context,
	PGPUserIDPropName	prop,
	void			   *val,
	PGPSize				len,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;
	PGPFilterRef	newFilter;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeUserIDBuffer, match, &newFilter);
	if( IsntPGPError( err ) )
	{
		PGPByte *		value;

		value = (PGPByte *)pgpContextMemAlloc( context, len, 0);
		if( IsntNull( value ) )
		{
			pgpCopyMemory (val, value, len);
			newFilter->value.propbuffer.prop = prop;
			newFilter->value.propbuffer.val = value;
			newFilter->value.propbuffer.len = len;
		}
		else
		{
			PGPFreeFilter( newFilter );
			newFilter	= NULL;
			err	= kPGPError_OutOfMemory;
		}
	}
	
	*outFilter = newFilter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewSigBooleanFilter(
	PGPContextRef		context,
	PGPSigPropName		prop,
	PGPBoolean			match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSigBoolean, kPGPMatchDefault, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.propbool.prop = prop;
		(*outFilter)->value.propbool.val = match;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewSigNumberFilter(
	PGPContextRef		context,
	PGPSigPropName		prop,
	PGPUInt32			val,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSigNumber, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.propnum.prop = prop;
		(*outFilter)->value.propnum.val = val;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewSigTimeFilter(
	PGPContextRef		context,
	PGPSigPropName		prop,
	PGPTime				val,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSigTime, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.proptime.prop = prop;
		(*outFilter)->value.proptime.val = val;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewSigPropertyBufferFilter(
	PGPContextRef		context,
	PGPSigPropName		prop,
	void			   *val,
	PGPSize				len,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;
	PGPFilterRef	newFilter;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSigBuffer, match, &newFilter);
	if( IsntPGPError( err ) )
	{
		PGPByte *		value;

		value = (PGPByte *)pgpContextMemAlloc( context, len, 0);
		if( IsntNull( value ) )
		{
			pgpCopyMemory (val, value, len);
			newFilter->value.propbuffer.prop = prop;
			newFilter->value.propbuffer.val = value;
			newFilter->value.propbuffer.len = len;
		}
		else
		{
			PGPFreeFilter( newFilter );
			newFilter	= NULL;
			err	= kPGPError_OutOfMemory;
		}
	}
	
	*outFilter = newFilter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}


#if NOT_YET		/* [ */

/*
 * Create a filtered KeySet based on the same KeyDB as the specified
 * original.  The original must be unfiltered.  The filtering type
 * is chosen automatically based on the string.
 *
 * Currently, a "0x" prefix looks up by keyID, otherwise
 * by userid name substring matching.
 */
	PGPError 
PGPNewKeyFilterFromStringQuery(
	PGPContextRef		context,
	char const *		query,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;
	PGPFilterRef	filter = kInvalidPGPKeySetRef;

	PGPValidatePtr( outFilter );
	PGPValidatePtr( query );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
not yet

	if (query[0] == '0' && query[1] == 'x')
	{
		PGPKeyIDRef		keyID;

		err = PGPNewKeyIDFromString( context, query, &keyID );
		if ( IsntPGPError( err ) )
		{
			err = PGPNewKeyIDFilter( context, keyID, &filter );
			PGPFreeKeyID( keyID );
		}
	}
	else
	{
		err = PGPNewUserIDStringFilter( context, query,
										kPGPMatchSubString,
										&filter );
	}

	*outFilter	= filter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

#endif	/* ] NOT_YET */

	static PGPBoolean
sComparisonMatchesCriterion(
	long				comparison,
	PGPMatchCriterion	criterion )
{
	switch (criterion)
	{
		case kPGPMatchLessOrEqual:
			return comparison <= 0;
		case kPGPMatchGreaterOrEqual:
			return comparison >= 0;
		case kPGPMatchEqual:
			return comparison == 0;
		default:
			pgpAssert(0);
			break;
	}
	return FALSE;
}

	static PGPBoolean
sKeyObjMatchesFilter(
	PGPContextRef		context,
	PGPFilterRef		filter,
	RingSet const *		ringSet,
	RingObject *		keyObj)
{
	long				comparison;
	PGPBoolean			result = FALSE;
	PGPByte				pkAlg;

	(void) context;
	
	pgpAssert(ringSet != NULL);
	switch(filter->filterType) 
	{
		case kPGPFilterTypeKeyKeyID:
		{
			PGPKeyID			keyID;
	
			ringKeyID8(ringSet, keyObj, &pkAlg, &keyID);

			result	= pgpKeyIDsEqual( &keyID, &filter->value.keyKeyID );
			break;
		}

		case kPGPFilterTypeKeyFingerPrint:
		{
			PGPSize		length;
			PGPByte		buffer[32];

			if (ringKeyV3(ringSet, keyObj))
			{
				ringKeyFingerprint16(ringSet, keyObj, buffer);
				length = 16;
			}
			else
			{
				ringKeyFingerprint20(ringSet, keyObj, buffer);
				length = 20;
			}
			if (filter->value.keyFingerPrint.keyFingerPrintLength == length)
			{
				result = !memcmp(buffer,
							filter->value.keyFingerPrint.keyFingerPrintData,
							length);
			}
			break;
		}

		/* Time filters, which utilize shared locals */
		{
			PGPTime		keyTime;
			PGPTime		filterTime;

		case kPGPFilterTypeKeyCreationTime:
			keyTime = ringKeyCreation(ringSet, keyObj);
			filterTime = filter->value.keyCreationTime;
			goto compareTimes;

		case kPGPFilterTypeKeyExpirationTime:
			keyTime = ringKeyExpiration(ringSet, keyObj);
			filterTime = filter->value.keyExpirationTime;

			/* FALL THROUGH */
		compareTimes:
			if (keyTime == filterTime)
				result = TRUE;	/* All match criteria include equality */
			else if (filter->match == kPGPMatchEqual)
				result = FALSE;
			else
			{
				/*
				 * Now we know that the two times are unequal,
				 * and the match criterion is either <= or >=.
				 * So we'll just evaluate <=, and then invert
				 * the result if the criterion was >=.
				 */
				result = (keyTime <= filterTime);
				if (filter->filterType == kPGPFilterTypeKeyExpirationTime)
				{
					if (filterTime == kPGPExpirationTime_Never)
						result = TRUE;
					else if (keyTime == kPGPExpirationTime_Never)
						result = FALSE;
				}

				if (filter->match == kPGPMatchGreaterOrEqual)
				{
					result = !result;
				}
				else
				{
					pgpAssert(filter->match == kPGPMatchLessOrEqual);
				}
			}
			break;
		}

		case kPGPFilterTypeKeyRevoked:
			result = ((!filter->value.keyRevoked)
					  == (!ringKeyRevoked(ringSet, keyObj)));
			break;
		case kPGPFilterTypeKeyDisabled:
			result = ((!filter->value.keyDisabled)
					  == (!ringKeyDisabled(ringSet, keyObj)));
			break;

		case kPGPFilterTypeKeyEncryptAlgorithm:
		{
			RingIterator *	ringIter;
			RingObject *	subKeyObj;

			ringKeyID8(ringSet, keyObj, &pkAlg, NULL);
			if (pkAlg == kPGPPublicKeyAlgorithm_RSA)
			{
				result = (pkAlg == filter->value.keyEncryptAlgorithm);
			}
			else
			{
				ringIter = ringIterCreate(ringSet);
				if (ringIter != NULL)
				{
					ringIterSeekTo(ringIter, keyObj);
					while (ringIterNextObject(ringIter, 2) == 2)
					{
						subKeyObj = ringIterCurrentObject(ringIter, 2);
						if (ringObjectType(subKeyObj) == RINGTYPE_KEY)
						{
							ringKeyID8(ringSet, subKeyObj, &pkAlg, NULL);
							if (pkAlg == filter->value.keyEncryptAlgorithm)
							{
								result = TRUE;
								break;
							}
						}
					}
					ringIterDestroy(ringIter);
				}
			}
			break;
		}
		case kPGPFilterTypeKeySigAlgorithm:
			ringKeyID8(ringSet, keyObj, &pkAlg, NULL);
			result = (pkAlg == filter->value.keySigAlgorithm);

/*			This is the code that was here previously that didn't work
			looks like it was an accidental paste. - jason

			result = (pkAlg == filter->value.keyEncryptAlgorithm);
			result = ((!filter->value.keySigAlgorithm)
					  == (!ringKeyRevoked(ringSet, keyObj)));
*/			break;
		case kPGPFilterTypeKeySubKeyID:
		{
			RingIterator *	ringIter;
			RingObject *	subKeyObj;

			ringIter = ringIterCreate(ringSet);
			if (ringIter != NULL)
			{
				ringIterSeekTo(ringIter, keyObj);
				while (ringIterNextObject(ringIter, 2) == 2)
				{
					subKeyObj = ringIterCurrentObject(ringIter, 2);
					if (ringObjectType(subKeyObj) == RINGTYPE_KEY)
					{
						PGPKeyID	keyID;
						
						ringKeyID8(ringSet, subKeyObj, NULL, &keyID);
						if ( pgpKeyIDsEqual( &keyID,
								&filter->value.keySubKeyID ) )
						{
							result = TRUE;
							break;
						}
					}
				}
				ringIterDestroy(ringIter);
			}
			break;
		}
		case kPGPFilterTypeSigKeyID:
		{
			RingIterator *	ringIter;
			RingObject *	sigObj;

			ringIter = ringIterCreate(ringSet);
			if (ringIter != NULL)
			{
				ringIterSeekTo(ringIter, keyObj);
				while (!result && ringIterNextObject(ringIter, 2) == 2)
				{
					while (ringIterNextObject(ringIter, 3) == 3)
					{
						sigObj = ringIterCurrentObject(ringIter, 3);
						if (ringObjectType(sigObj) == RINGTYPE_SIG)
						{
							PGPKeyID	keyID;
						
							ringSigID8(ringSet, sigObj, NULL, &keyID);
							if ( pgpKeyIDsEqual( &keyID,
									&filter->value.sigKeyID ))
							{
								result = TRUE;
								break;
							}
						}
					}
				}
				ringIterDestroy(ringIter);
			}
			break;
		}
		case kPGPFilterTypeKeyEncryptKeySize:
		{
			RingIterator *	ringIter;
			RingObject *	subKeyObj;

			ringKeyID8(ringSet, keyObj, &pkAlg, NULL);
			if (pkAlg == kPGPPublicKeyAlgorithm_RSA)
			{
				comparison = (ringKeyBits(ringSet, keyObj)
								  - filter->value.keyEncryptKeySize);
				result = sComparisonMatchesCriterion(comparison,
													 filter->match);
			}
			else
			{
				ringIter = ringIterCreate(ringSet);
				if (ringIter != NULL)
				{
					ringIterSeekTo(ringIter, keyObj);
					while (ringIterNextObject(ringIter, 2) == 2)
					{
						subKeyObj = ringIterCurrentObject(ringIter, 2);
						if (ringObjectType(subKeyObj) == RINGTYPE_KEY)
						{
							comparison = (ringKeyBits(ringSet, subKeyObj)
											- filter->value.keyEncryptKeySize);
							if (sComparisonMatchesCriterion(comparison,
															filter->match))
							{
								result = TRUE;
								break;
							}
						}
					}
					ringIterDestroy(ringIter);
				}
			}
			break;
		}
		case kPGPFilterTypeKeySigKeySize:
			comparison = (ringKeyBits(ringSet, keyObj)
							  - filter->value.keySigKeySize);
			result = sComparisonMatchesCriterion(comparison, filter->match);
			break;

		/* UserID filters, which utilize shared locals */