In configuration settings of the ChakraCore JS engine was added one new property - AllowReflection (default false)

Author: Taritsyn

src/JavaScriptEngineSwitcher.ChakraCore/ChakraCoreJsEngine.cs

@@ -73,7 +73,7 @@ public sealed class ChakraCoreJsEngine : JsEngineBase
 		/// <summary>
 		/// Type mapper
 		/// </summary>
-		private TypeMapper _typeMapper = new TypeMapper();
+		private TypeMapper _typeMapper;
 
 		/// <summary>
 		/// Callback for continuation of promise
@@ -148,6 +148,7 @@ public ChakraCoreJsEngine(ChakraCoreSettings settings)
 				attributes |= JsRuntimeAttributes.EnableExperimentalFeatures;
 			}
 
+			_typeMapper = new TypeMapper(chakraCoreSettings.AllowReflection);
 #if NETSTANDARD1_3
 			_dispatcher = new ScriptDispatcher();
 #else

src/JavaScriptEngineSwitcher.ChakraCore/ChakraCoreSettings.cs

@@ -28,6 +28,19 @@ public sealed class ChakraCoreSettings
 		private int _maxStackSize;
 
 #endif
+		/// <summary>
+		/// Gets or sets a flag for whether to allow the usage of reflection API in the script code
+		/// </summary>
+		/// <remarks>
+		/// This affects <see cref="Object.GetType"/>, <c>Exception.GetType</c>,
+		/// <c>Exception.TargetSite</c> and <c>Delegate.Method</c>.
+		/// </remarks>
+		public bool AllowReflection
+		{
+			get;
+			set;
+		}
+
 		/// <summary>
 		/// Gets or sets a flag for whether to disable any background work (such as garbage collection)
 		/// on background threads
@@ -136,6 +149,7 @@ public ChakraCoreSettings()
 		{
 			bool is64BitProcess = Utils.Is64BitProcess();
 
+			AllowReflection = false;
 			DisableBackgroundWork = false;
 			DisableEval = false;
 			DisableExecutablePageAllocation = false;

src/JavaScriptEngineSwitcher.ChakraCore/Helpers/ReflectionHelpers.cs

@@ -12,6 +12,19 @@ namespace JavaScriptEngineSwitcher.ChakraCore.Helpers
 	/// </summary>
 	internal static class ReflectionHelpers
 	{
+		private static readonly PropertyInfo[] _disallowedProperties =
+		{
+			typeof(Delegate).GetProperty("Method"),
+			typeof(Exception).GetProperty("TargetSite")
+		};
+
+		private static readonly MethodInfo[] _disallowedMethods =
+		{
+			typeof(object).GetMethod("GetType"),
+			typeof(Exception).GetMethod("GetType")
+		};
+
+
 		public static BindingFlags GetDefaultBindingFlags(bool instance)
 		{
 			BindingFlags bindingFlags = BindingFlags.Public;
@@ -27,6 +40,20 @@ public static BindingFlags GetDefaultBindingFlags(bool instance)
 			return bindingFlags;
 		}
 
+		public static bool IsAllowedProperty(PropertyInfo property)
+		{
+			bool isAllowed = !_disallowedProperties.Contains(property, MemberComparer<PropertyInfo>.Instance);
+
+			return isAllowed;
+		}
+
+		public static bool IsAllowedMethod(MethodInfo method)
+		{
+			bool isAllowed = !_disallowedMethods.Contains(method, MemberComparer<MethodInfo>.Instance);
+
+			return isAllowed;
+		}
+
 		public static bool IsFullyFledgedMethod(MethodInfo method)
 		{
 			if (!method.Attributes.HasFlag(MethodAttributes.SpecialName))
@@ -221,6 +248,38 @@ private static bool CompareParameterTypes(object[] argValues, Type[] argTypes, T
 		}
 
 
+		private sealed class MemberComparer<T> : EqualityComparer<T>
+			where T : MemberInfo
+		{
+			public static MemberComparer<T> Instance { get; } = new MemberComparer<T>();
+
+
+			private MemberComparer()
+			{ }
+
+
+			#region MemberComparer overrides
+
+			public override bool Equals(T x, T y)
+			{
+				return x.Module == y.Module
+#if !NETSTANDARD1_3
+					&& x.MetadataToken == y.MetadataToken
+#else
+					&& x.DeclaringType == y.DeclaringType
+					&& x.Name == y.Name
+#endif
+					;
+			}
+
+			public override int GetHashCode(T obj)
+			{
+				return obj != null ? obj.GetHashCode() : 0;
+			}
+
+			#endregion
+		}
+
 		private sealed class MethodWithMetadata
 		{
 			public MethodBase Method

src/JavaScriptEngineSwitcher.ChakraCore/JavaScriptEngineSwitcher.ChakraCore.csproj

@@ -31,7 +31,7 @@ This package does not contain the native implementations of ChakraCore. Therefor
  * JavaScriptEngineSwitcher.ChakraCore.Native.osx-x64</Description>
     <PackageTags>$(PackageCommonTags);ChakraCore</PackageTags>
     <PackageIconFullPath>../../Icons/JavaScriptEngineSwitcher_ChakraCore_Logo128x128.png</PackageIconFullPath>
-    <PackageReleaseNotes>ChakraCore was updated to version of November 9, 2022.</PackageReleaseNotes>
+    <PackageReleaseNotes>In configuration settings of the ChakraCore JS engine was added one new property - `AllowReflection` (default `false`).</PackageReleaseNotes>
   </PropertyGroup>
 
   <ItemGroup>

src/JavaScriptEngineSwitcher.ChakraCore/JsRt/TypeMapper.cs

@@ -31,6 +31,11 @@ internal sealed class TypeMapper : IDisposable
 		/// </summary>
 		private const string ExternalObjectPropertyName = "_JavaScriptEngineSwitcher_externalObject";
 
+		/// <summary>
+		/// Flag for whether to allow the usage of reflection API in the script code
+		/// </summary>
+		private readonly bool _allowReflection;
+
 		/// <summary>
 		/// Storage for lazy-initialized embedded objects
 		/// </summary>
@@ -80,8 +85,11 @@ internal sealed class TypeMapper : IDisposable
 		/// <summary>
 		/// Constructs an instance of type mapper
 		/// </summary>
-		public TypeMapper()
-		{ }
+		/// <param name="allowReflection">Flag for whether to allow the usage of reflection API in the script code</param>
+		public TypeMapper(bool allowReflection)
+		{
+			_allowReflection = allowReflection;
+		}
 
 
 		/// <summary>
@@ -604,6 +612,11 @@ private void ProjectProperties(EmbeddedItem externalItem)
 
 			foreach (PropertyInfo property in properties)
 			{
+				if (!IsAvailableProperty(property))
+				{
+					continue;
+				}
+
 				string propertyName = property.Name;
 
 				JsValue descriptorValue = JsValue.CreateObject();
@@ -732,14 +745,13 @@ private void ProjectMethods(EmbeddedItem externalItem)
 
 			string typeName = type.FullName;
 			BindingFlags defaultBindingFlags = ReflectionHelpers.GetDefaultBindingFlags(instance);
-			IEnumerable<MethodInfo> methods = type.GetMethods(defaultBindingFlags)
-				.Where(ReflectionHelpers.IsFullyFledgedMethod);
-			IEnumerable<IGrouping<string, MethodInfo>> methodGroups = methods.GroupBy(m => m.Name);
+			MethodInfo[] methods = type.GetMethods(defaultBindingFlags);
+			Dictionary<string, List<MethodInfo>> availableMethodGroups = GetAvailableMethodGroups(methods);
 
-			foreach (IGrouping<string, MethodInfo> methodGroup in methodGroups)
+			foreach (KeyValuePair<string, List<MethodInfo>> methodGroup in availableMethodGroups)
 			{
 				string methodName = methodGroup.Key;
-				MethodInfo[] methodCandidates = methodGroup.ToArray();
+				MethodInfo[] methodCandidates = methodGroup.Value.ToArray();
 
 				JsNativeFunction nativeFunction = (callee, isConstructCall, args, argCount, callbackData) =>
 				{
@@ -808,6 +820,55 @@ private void ProjectMethods(EmbeddedItem externalItem)
 			}
 		}
 
+		[MethodImpl((MethodImplOptions)256 /* AggressiveInlining */)]
+		private bool IsAvailableProperty(PropertyInfo property)
+		{
+			if (_allowReflection)
+			{
+				return true;
+			}
+
+			bool isAvailable = ReflectionHelpers.IsAllowedProperty(property);
+
+			return isAvailable;
+		}
+
+		[MethodImpl((MethodImplOptions)256 /* AggressiveInlining */)]
+		private Dictionary<string, List<MethodInfo>> GetAvailableMethodGroups(MethodInfo[] methods)
+		{
+			int methodCount = methods.Length;
+			if (methodCount == 0)
+			{
+				return new Dictionary<string, List<MethodInfo>>();
+			}
+
+			var availableMethodGroups = new Dictionary<string, List<MethodInfo>>(methodCount);
+
+			foreach (MethodInfo method in methods)
+			{
+				if (!ReflectionHelpers.IsFullyFledgedMethod(method)
+					|| (!_allowReflection && !ReflectionHelpers.IsAllowedMethod(method)))
+				{
+					continue;
+				}
+
+				string methodName = method.Name;
+				List<MethodInfo> methodGroup;
+
+				if (availableMethodGroups.TryGetValue(methodName, out methodGroup))
+				{
+					methodGroup.Add(method);
+				}
+				else
+				{
+					methodGroup = new List<MethodInfo> { method };
+					availableMethodGroups.Add(methodName, methodGroup);
+				}
+			}
+
+			return availableMethodGroups;
+		}
+
 		private object[] GetHostItemMemberArguments(JsValue[] args, int maxArgCount = -1)
 		{
 			if (args == null)

src/JavaScriptEngineSwitcher.ChakraCore/readme.txt

@@ -31,7 +31,8 @@
    =============
    RELEASE NOTES
    =============
-   ChakraCore was updated to version of November 9, 2022.
+   In configuration settings of the ChakraCore JS engine was added one new
+   property - `AllowReflection` (default `false`).
 
    =============
    DOCUMENTATION