pgpkeyfilter.c

可以实现对邮件的加密解密以及签名

				if( IsPGPError( err ) )
					continue;
				result = sCompareString( filter, bufval, buflen );
				PGPFreeData( bufval );
			}
			break;
		case kPGPFilterTypeSigBoolean:
			if( filter->filterChildren
				&& IsntNull( sig = sFindParent( obj, RINGTYPE_SIG ) ) )
			{
				err = pgpGetSigBoolean (sig,
							(PGPKeyDBObjProperty)filter->value.propbool.prop,
							&boolval);
				if( IsntPGPError( err ) )
					result = sCompareBoolean( filter, boolval );
			} else for (userid = key->down; !result && IsntNull(userid);
							 	userid = userid->next)
			{
				if (!pgpKeyDBObjIsReal( userid) )
					continue;
			    for (sig = userid->down; !result && IsntNull(sig);
									sig = sig->next)
				{
					if (!pgpKeyDBObjIsReal( sig) )
						continue;
					if( pgpObjectType( sig ) != RINGTYPE_SIG )
						continue;
					err = pgpGetSigBoolean (sig,
								(PGPKeyDBObjProperty)filter->value.propbool.prop,
								&boolval);
					if( IsntPGPError( err ) )
						result = sCompareBoolean( filter, boolval );
				}
			}
			break;
		case kPGPFilterTypeSigNumber:
			if( filter->filterChildren
				&& IsntNull( sig = sFindParent( obj, RINGTYPE_SIG ) ) )
			{
				err = pgpGetSigNumber (sig,
								(PGPKeyDBObjProperty)filter->value.propnum.prop,
								(PGPInt32 *)&numval);
				if( IsntPGPError( err ) )
					result = sCompareNumber( filter, numval );
			} else for (userid = key->down; !result && IsntNull(userid);
							 	userid = userid->next)
			{
				if (!pgpKeyDBObjIsReal( userid) )
					continue;
			    for (sig = userid->down; !result && IsntNull(sig);
									sig = sig->next)
				{
					if (!pgpKeyDBObjIsReal( sig) )
						continue;
					if( pgpObjectType( sig ) != RINGTYPE_SIG )
						continue;
					err = pgpGetSigNumber (sig,
									(PGPKeyDBObjProperty)filter->value.propnum.prop,
									(PGPInt32 *)&numval);
					if( IsntPGPError( err ) )
						result = sCompareNumber( filter, numval );
				}
			}
			break;
		case kPGPFilterTypeSigTime:
			if( filter->filterChildren
				&& IsntNull( sig = sFindParent( obj, RINGTYPE_SIG ) ) )
			{
				err = pgpGetSigTime (sig,
							(PGPKeyDBObjProperty)filter->value.proptime.prop,
							&timeval);
				if( IsntPGPError( err ) )
					result = sCompareTime( filter, timeval );
			} else for (userid = key->down; !result && IsntNull(userid);
							 	userid = userid->next)
			{
				if (!pgpKeyDBObjIsReal( userid) )
					continue;
			    for (sig = userid->down; !result && IsntNull(sig);
									sig = sig->next)
				{
					if (!pgpKeyDBObjIsReal( sig) )
						continue;
					if( pgpObjectType( sig ) != RINGTYPE_SIG )
						continue;
					err = pgpGetSigTime (sig,
								(PGPKeyDBObjProperty)filter->value.proptime.prop,
								&timeval);
					if( IsntPGPError( err ) )
						result = sCompareTime( filter, timeval );
				}
			}
			break;
		case kPGPFilterTypeSigBuffer:
			if( filter->filterChildren
				&& IsntNull( sig = sFindParent( obj, RINGTYPE_SIG ) ) )
			{
				err = pgpGetSigAllocatedPropertyBuffer( sig,
						(PGPKeyDBObjProperty)filter->value.propbuffer.prop,
						&bufval, &buflen );
				if( IsPGPError( err ) )
					break;
				result = sCompareString( filter, bufval, buflen );
				PGPFreeData( bufval );
			} else for (userid = key->down; !result && IsntNull(userid);
							 	userid = userid->next)
			{
				if (!pgpKeyDBObjIsReal( userid) )
					continue;
			    for (sig = userid->down; !result && IsntNull(sig);
									sig = sig->next)
				{
					if (!pgpKeyDBObjIsReal( sig) )
						continue;
					if( pgpObjectType( sig ) != RINGTYPE_SIG )
						continue;
					err = pgpGetSigAllocatedPropertyBuffer( sig,
							(PGPKeyDBObjProperty)filter->value.propbuffer.prop,
							&bufval, &buflen );
					if( IsPGPError( err ) )
						continue;
					result = sCompareString( filter, bufval, buflen );
					PGPFreeData( bufval );
				}
			}
			break;

		case kPGPFilterTypeKeyKeyID:
			pgpKeyID8(key, &pkAlg, &keyID);
			result	= pgpKeyIDsEqual( &keyID, &filter->value.keyKeyID );
			break;

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

			if (pgpKeyV3(key))
			{
				pgpKeyFingerprint16(key, buffer);
				length = 16;
			}
			else
			{
				pgpKeyFingerprint20(key, 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 = pgpKeyCreation(key);
			filterTime = filter->value.keyCreationTime;
			goto compareTimes;

		case kPGPFilterTypeKeyExpirationTime:
			keyTime = pgpKeyExpiration(key);
			filterTime = filter->value.keyExpirationTime;

			/* FALL THROUGH */
		compareTimes:
			if (keyTime == filterTime)
				result = TRUE;	/* All match criteria include equality */
			else if (filter->match == kPGPMatchCriterion_Equal)
				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 == kPGPMatchCriterion_GreaterOrEqual)
				{
					result = !result;
				}
				else
				{
					pgpAssert(filter->match == kPGPMatchCriterion_LessOrEqual);
				}
			}
			break;
		}

		case kPGPFilterTypeKeyRevoked:
			result = ((!filter->value.keyRevoked)
					  == (!pgpKeyRevoked(key)));
			break;
		case kPGPFilterTypeKeyDisabled:
			result = ((!filter->value.keyDisabled)
					  == (!pgpKeyDisabled(key)));
			break;

		case kPGPFilterTypeKeyEncryptAlgorithm:
			pgpKeyID8(key, &pkAlg, NULL);
			if( pkAlg == filter->value.keyEncryptAlgorithm )
			{
				result = TRUE;
			} else if( filter->filterChildren
				&& IsntNull( subkey = sFindParent( obj, RINGTYPE_SUBKEY ) ) )
			{
				pgpKeyID8(subkey, &pkAlg, NULL);
				result = (pkAlg == filter->value.keyEncryptAlgorithm);
			} else for (subkey = key->down; !result && IsntNull( subkey );
				 				subkey = subkey->next)
			{
				if (!pgpKeyDBObjIsReal( subkey ) )
					continue;
				if( pgpObjectType( subkey ) != RINGTYPE_SUBKEY )
					continue;
				pgpKeyID8( subkey, &pkAlg, NULL );
				if (pkAlg == filter->value.keyEncryptAlgorithm)
				{
					result = TRUE;
					break;
				}
			}
			break;

		case kPGPFilterTypeKeySigAlgorithm:
			pgpKeyID8(key, &pkAlg, NULL);
			result = (pkAlg == filter->value.keySigAlgorithm);
			break;

		case kPGPFilterTypeKeySubKeyID:
			if( filter->filterChildren
				&& IsntNull( subkey = sFindParent( obj, RINGTYPE_SUBKEY ) ) )
			{
				pgpKeyID8(subkey, NULL, &keyID);
				result = pgpKeyIDsEqual( &keyID, &filter->value.keySubKeyID );
			} else for (subkey = key->down; !result && IsntNull( subkey );
				 				subkey = subkey->next)
			{
				if (!pgpKeyDBObjIsReal( subkey ) )
					continue;
				if( pgpObjectType( subkey ) != RINGTYPE_SUBKEY )
					continue;
				pgpKeyID8(subkey, NULL, &keyID);
				if ( pgpKeyIDsEqual( &keyID, &filter->value.keySubKeyID ) )
				{
					result = TRUE;
					break;
				}
			}
			break;

		case kPGPFilterTypeSigKeyID:
			if( filter->filterChildren
				&& IsntNull( sig = sFindParent( obj, RINGTYPE_SIG ) ) )
			{
				pgpSigID8( sig, NULL, &keyID);
				result = pgpKeyIDsEqual( &keyID, &filter->value.sigKeyID );
			} else for (userid = key->down; !result && IsntNull(userid);
							 	userid = userid->next)
			{
				if (!pgpKeyDBObjIsReal( userid) )
					continue;
			    for (sig = userid->down; !result && IsntNull(sig);
									sig = sig->next)
				{
					if (!pgpKeyDBObjIsReal( sig) )
						continue;
					if( pgpObjectType( sig ) != RINGTYPE_SIG )
						continue;
					pgpSigID8( sig, NULL, &keyID);
					if ( pgpKeyIDsEqual( &keyID, &filter->value.sigKeyID ))
					{
						result = TRUE;
						break;
					}
				}
			}
			break;

		case kPGPFilterTypeKeyEncryptKeySize:
			if( (pgpKeyUse( key ) & PGP_PKUSE_ENCRYPT) )
			{
				comparison = pgpKeyBits(key)
								- filter->value.keyEncryptKeySize;
				result = sComparisonMatchesCriterion(comparison,
													  filter->match);
			} else if( filter->filterChildren
				&& IsntNull( subkey = sFindParent( obj, RINGTYPE_SUBKEY ) ) )
			{
				comparison = pgpKeyBits(subkey)
								- filter->value.keyEncryptKeySize;
				result = sComparisonMatchesCriterion(comparison,
													  filter->match);
			} else for (subkey = key->down; !result && IsntNull( subkey );
				 				subkey = subkey->next)
			{
				if (!pgpKeyDBObjIsReal( subkey ) )
					continue;
				if( pgpObjectType( subkey ) != RINGTYPE_SUBKEY )
					continue;
				comparison = (pgpKeyBits(subkey)
								- filter->value.keyEncryptKeySize);
				if (sComparisonMatchesCriterion(comparison, filter->match))
				{
					result = TRUE;
					break;
				}
			}
			break;

		case kPGPFilterTypeKeySigKeySize:
			comparison = pgpKeyBits(key) - filter->value.keySigKeySize;
			result = sComparisonMatchesCriterion(comparison, filter->match);
			break;

		/* UserID filters, which utilize shared locals */
		{
			char *			string;
			PGPSize			stringLength;

		case kPGPFilterTypeUserIDEmail:
			string = filter->value.userIDEmail;
			stringLength = strlen(string);
			goto stringFilter;

		case kPGPFilterTypeUserIDName:
			string = filter->value.userIDName;
			stringLength = strlen(string);
			goto stringFilter;
			
		case kPGPFilterTypeUserIDString:
			string = filter->value.userIDString; 
			stringLength = strlen(string);

			/* FALL THROUGH */
		stringFilter:
			if( filter->filterChildren
				&& IsntNull( userid = sFindParent( obj, RINGTYPE_USERID ) ) )
			{
				if( pgpUserIDIsAttribute( userid ) )
					break;
				result = sFilterUserID( filter, userid, string, stringLength );
			} else for (userid = key->down; !result && IsntNull(userid);
							 	userid = userid->next)
			{
				if (!pgpKeyDBObjIsReal( userid) )
					continue;
				if( pgpObjectType( userid ) != RINGTYPE_USERID )
					continue;
				if( pgpUserIDIsAttribute( userid ) )
					continue;
				if( sFilterUserID( filter, userid, string, stringLength ) )
				{
					result = TRUE;
					break;
				}
			}
			break;
		}


		/* Compound filters */
		case kPGPFilterTypeNot:
			result = !pgpKeyDBObjMatchesFilter(filter->value.notFilter, obj);
			break;
		case kPGPFilterTypeAnd:
			result = pgpKeyDBObjMatchesFilter(filter->value.andFilter.andFilter1,
											obj)
				  && pgpKeyDBObjMatchesFilter(filter->value.andFilter.andFilter2,
											obj);
			break;
		case kPGPFilterTypeOr:
			result = pgpKeyDBObjMatchesFilter(filter->value.orFilter.orFilter1,
											obj)
				  || pgpKeyDBObjMatchesFilter(filter->value.orFilter.orFilter2,
											obj);
			break;


		default:
			pgpAssertMsg(FALSE, "Unimplemented filter type");
			break;

	}

	/* Cache answer for future sub-object query */
	if( pgpObjectType( obj ) == RINGTYPE_KEY )
	{
		filter->cachedKeyQuery = obj;
		filter->cachedResult = result;
	}

	return result;
}

static PGPError
pgpEncodeSearchTerms( PGPContextRef context,
				char *var,
				PGPSize varlen,
				char **newString )
{
	/* static char const badChars[]   = "*()"; */
	/* We don't want to escape *'s */
	static char const badChars[]   = "()";
	char		*ptrBad;
	char		*ptrGood;
	PGPInt16	i;
	PGPSize		j					= 0;

	*newString = (char*) pgpContextMemAlloc( context,
								2*varlen+1,
								kPGPMemoryMgrFlags_Clear );
	if ( *newString == NULL )
	{
		return kPGPError_OutOfMemory;
	}

	ptrBad  = var;
	ptrGood = *newString;

	while ( ( j++ < varlen ) && ( *ptrBad != '\0' ) )
	{
		for (i=0; badChars[i] != '\0'; i++ )
		{
			if ( *ptrBad == badChars[i] )
			{
				*ptrGood++ = '\\';
				*ptrGood++ = *ptrBad++;
				break;
			}
		}
		if (badChars[i] == '\0')
		{
			*ptrGood++ = *ptrBad++;
		}
	}
	*ptrGood = '\0';

	return kPGPError_NoErr;
}


static PGPError
pgpGrowQueryString(PGPContextRef context,
			char **query, PGPUInt16 *maxsize, PGPUInt16 growthfactor)
{
	PGPError	err;

	if ( strlen(*query) + growthfactor + 1 > *maxsize )
	{
		if (growthfactor < 500)
		{
			growthfactor = 500;
		}
		err = pgpContextMemRealloc( context, (void **)query, 
							*maxsize + growthfactor + 1, 0 );
		if ( IsPGPError(err) )
		{
			return err;
		}
		*maxsize += 500;
	}
	return kPGPError_NoErr;
}

static PGPError
pgpBuildLDAPQuery( 
	PGPFilterRef filter, 
	PGPBoolean *disableVisited,
	char **query, 
	PGPUInt16 *maxsize  )
{
	PGPError	err			= kPGPError_NoErr;
	PGPUInt32	numvalue;
	PGPBoolean	boolvalue;
	PGPTime		timevalue;
	void	   *strvalue;
	PGPSize		strsize;
	char		*newString  = NULL;
	char		keyIDBuffer[ 128 ];
	char		buffer[500];

	switch (filter->filterType)
	{
		case kPGPFilterTypeAnd:
		{
			err = pgpGrowQueryString(filter->context, query, maxsize, 10);
			if ( IsPGPError(err) )
			{
				return kPGPError_OutOfMemory;
			}
			strcat( *query, "(&" );

			err = pgpBuildLDAPQuery(filter->value.andFilter.andFilter1,
								disableVisited, query, maxsize );
			if (err != kPGPError_NoErr)
			{
				return err;
			}
			err = pgpBuildLDAPQuery(filter->value.andFilter.andFilter2,
								disableVisited, query, maxsize );
			if (err != kPGPError_NoErr)
			{
				return err;
			}
			err = pgpGrowQueryString(filter->context, query, maxsize, 10);
			if ( IsPGPError(err) )
			{