Microsoft Exchange Server CVE-2023-36745

public SharedTypeResolver(string assemblyLoadPath = null)
{
	if (string.IsNullOrEmpty(assemblyLoadPath))
	{
		assemblyLoadPath = ExchangeSetupContext.BinPath;
	}
	this.fusePaxosAsm = Assembly.LoadFrom(Path.Combine(assemblyLoadPath, "FUSE.Paxos.dll"));
	this.typeCache = new ConcurrentDictionary<string, Type>();
	this.typeNameCache = new ConcurrentDictionary<string, string>();
	this.typeNameSpaceCache = new ConcurrentDictionary<string, string>();
}

public static Type LoadType(string assemblyName, string typeName, bool throwExceptionForMissingType, DeserializeLocation location, bool strictMode)
{
	Type type = null;
	try
	{
		type = Type.GetType(string.Format("{0}, {1}", typeName, assemblyName));
	}
	catch (TypeLoadException)
	{
	}
	catch (FileLoadException)
	{
	}
	if (type == null)
	{
		string shortName = assemblyName.Split(new char[] { ',' })[0];
		try
		{
			type = Type.GetType(string.Format("{0}, {1}", typeName, shortName));
		}
		catch (TypeLoadException)
		{
		}
		catch (FileLoadException)
		{
		}
		if (type == null)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			IEnumerable<Assembly> enumerable = assemblies.Where((Assembly x) => shortName == x.FullName.Split(new char[] { ',' })[0]);
			Assembly assembly = (enumerable.Any<Assembly>() ? enumerable.First<Assembly>() : null);
			try
			{
				if (assembly != null)
				{
					type = assembly.GetType(typeName);
				}
			}
			catch (TypeLoadException)
			{
			}
			catch (FileLoadException)
			{
			}
			if (type == null)
			{
				foreach (Assembly assembly2 in assemblies)
				{
					try
					{
						type = assembly2.GetType(typeName);
						if (type != null)
						{
							break;
						}
					}
					catch
					{
					}
				}
				if (type == null)
				{
					try
					{
						type = ChainedSerializationBinder.ParseAndLoadGenericType(assemblyName, typeName, location, strictMode);
					}
					catch
					{
					}
				}
			}
		}
	}
	if (type == null)
	{
		DeserializationTypeLogger.Singleton.Log(typeName, BlockReason.InDeny, location, strictMode ? DeserializationTypeLogger.BlockStatus.TrulyBlocked : DeserializationTypeLogger.BlockStatus.WouldBeBlocked);
		if (throwExceptionForMissingType)
		{
			throw new BlockedDeserializeTypeException(typeName + ", " + assemblyName, BlockReason.InDeny, location);
		}
	}
	return type;
}

public override Type BindToType(string assemblyName, string typeName)
{
	if (this.serializationOnly)
	{
		throw new InvalidOperationException("ChainedSerializationBinder was created for serialization only.  This instance cannot be used for deserialization.");
	}
	Type type = this.InternalBindToType(assemblyName, typeName);
	if (type != null)
	{
		string text;
		BlockReason blockReason = this.ValidateTypeToDeserialize(type, null, null, out text);
		this.EnforceBlockReason(blockReason, text);
	}
	else
	{
		BlockReason blockReason2 = this.EvaluateTypeStringAgainstDenyLists(typeName);
		this.EnforceBlockReason(blockReason2, typeName);
	}
	return type;
}

public BlockReason ValidateTypeToDeserialize(Type typeToDeserialize, ISet<string> additionalAllowedTypes, ISet<string> additionalAllowedGenerics, out string correctedTypeName)
{
	ChainedSerializationBinder.IsTypeExplicitlyDenied(typeToDeserialize, this.location, out correctedTypeName);
	if (!this.IsTypeExplicitlyAllowed(typeToDeserialize, additionalAllowedTypes, additionalAllowedGenerics, out correctedTypeName))
	{
		return BlockReason.NotInAllow;
	}
	return BlockReason.Allowed;
}

public bool IsTypeExplicitlyAllowed(Type typeToDeserialize, ISet<string> additionalAllowedTypes, ISet<string> additionalAllowedGenerics, out string correctedTypeName)
{
	if (typeToDeserialize == null)
	{
		correctedTypeName = "<NULL>";
		return true;
	}
	correctedTypeName = typeToDeserialize.FullName;
	if (typeToDeserialize.IsConstructedGenericType || typeToDeserialize.IsGenericTypeDefinition)
	{
		correctedTypeName = typeToDeserialize.GetGenericTypeDefinition().FullName;
		if (ChainedSerializationBinder.AlwaysAllowedGenerics.Contains(correctedTypeName) || (this.allowedGenericsForDeserialization != null && this.allowedGenericsForDeserialization.Contains(correctedTypeName)) || (additionalAllowedGenerics != null && additionalAllowedGenerics.Contains(correctedTypeName)))
		{
			return true;
		}
	}
	else if (ChainedSerializationBinder.AlwaysAllowedPrimitives.Contains(correctedTypeName) || (this.allowedTypesForDeserialization != null && this.allowedTypesForDeserialization.Contains(correctedTypeName)) || (additionalAllowedTypes != null && additionalAllowedTypes.Contains(correctedTypeName)))
	{
		return true;
	}
	return typeToDeserialize.IsArray || typeToDeserialize.IsEnum || typeToDeserialize.IsAbstract || typeToDeserialize.IsInterface;
}

public void EnforceBlockReason(BlockReason blockReason, string typeName)
{
	try
	{
		switch (blockReason)
		{
		case BlockReason.Invalid:
		case BlockReason.InDeny:
		case BlockReason.InDenySurrogate:
			throw new BlockedDeserializeTypeException(typeName, blockReason, this.location);
		case BlockReason.NotInAllow:
			if (this.strictMode)
			{
				throw new BlockedDeserializeTypeException(typeName, blockReason, this.location);
			}
			break;
		}
	}
	finally
	{
		if (blockReason != BlockReason.Allowed)
		{
			DeserializationTypeLogger.Singleton.Log(typeName, blockReason, this.location, this.strictMode ? DeserializationTypeLogger.BlockStatus.TrulyBlocked : DeserializationTypeLogger.BlockStatus.WouldBeBlocked);
		}
	}
}