using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Preloader.RuntimeFixes;
using Mono.Cecil;
namespace BepInEx.Preloader.Patching
{
///
/// Delegate used in patching assemblies.
///
/// The assembly that is being patched.
internal delegate void AssemblyPatcherDelegate(ref AssemblyDefinition assembly);
///
/// Worker class which is used for loading and patching entire folders of assemblies, or alternatively patching and
/// loading assemblies one at a time.
///
internal static class AssemblyPatcher
{
private const BindingFlags ALL = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.IgnoreCase;
public static List PatcherPlugins { get; } = new List();
private static readonly string DumpedAssembliesPath = Path.Combine(Paths.BepInExRootPath, "DumpedAssemblies");
///
/// Adds a single assembly patcher to the pool of applicable patches.
///
/// Patcher to apply.
public static void AddPatcher(PatcherPlugin patcher)
{
PatcherPlugins.Add(patcher);
}
private static T CreateDelegate(MethodInfo method) where T : class => method != null ? Delegate.CreateDelegate(typeof(T), method) as T : null;
private static PatcherPlugin ToPatcherPlugin(TypeDefinition type)
{
if (type.IsInterface || type.IsAbstract && !type.IsSealed)
return null;
var targetDlls = type.Methods.FirstOrDefault(m => m.Name.Equals("get_TargetDLLs", StringComparison.InvariantCultureIgnoreCase) &&
m.IsPublic &&
m.IsStatic);
if (targetDlls == null ||
targetDlls.ReturnType.FullName != "System.Collections.Generic.IEnumerable`1")
return null;
var patch = type.Methods.FirstOrDefault(m => m.Name.Equals("Patch") &&
m.IsPublic &&
m.IsStatic &&
m.ReturnType.FullName == "System.Void" &&
m.Parameters.Count == 1 &&
(m.Parameters[0].ParameterType.FullName == "Mono.Cecil.AssemblyDefinition&" ||
m.Parameters[0].ParameterType.FullName == "Mono.Cecil.AssemblyDefinition"));
if (patch == null)
return null;
return new PatcherPlugin
{
TypeName = type.FullName
};
}
///
/// Adds all patchers from all managed assemblies specified in a directory.
///
/// Directory to search patcher DLLs from.
/// A function that locates assembly patchers in a given managed assembly.
public static void AddPatchersFromDirectory(string directory)
{
if (!Directory.Exists(directory))
return;
var sortedPatchers = new SortedDictionary();
var patchers = TypeLoader.FindPluginTypes(directory, ToPatcherPlugin);
foreach (var keyValuePair in patchers)
{
var assemblyPath = keyValuePair.Key;
var patcherCollection = keyValuePair.Value;
if(patcherCollection.Count == 0)
continue;
var ass = Assembly.LoadFile(assemblyPath);
foreach (var patcherPlugin in patcherCollection)
{
try
{
var type = ass.GetType(patcherPlugin.TypeName);
var methods = type.GetMethods(ALL);
patcherPlugin.Initializer = CreateDelegate(methods.FirstOrDefault(m => m.Name.Equals("Initialize", StringComparison.InvariantCultureIgnoreCase) &&
m.GetParameters().Length == 0 &&
m.ReturnType == typeof(void)));
patcherPlugin.Finalizer = CreateDelegate(methods.FirstOrDefault(m => m.Name.Equals("Finish", StringComparison.InvariantCultureIgnoreCase) &&
m.GetParameters().Length == 0 &&
m.ReturnType == typeof(void)));
patcherPlugin.TargetDLLs = CreateDelegate>>(type.GetProperty("TargetDLLs", ALL).GetGetMethod());
var patcher = methods.FirstOrDefault(m => m.Name.Equals("Patch", StringComparison.CurrentCultureIgnoreCase) &&
m.ReturnType == typeof(void) &&
m.GetParameters().Length == 1 &&
(m.GetParameters()[0].ParameterType == typeof(AssemblyDefinition) ||
m.GetParameters()[0].ParameterType == typeof(AssemblyDefinition).MakeByRefType()));
patcherPlugin.Patcher = (ref AssemblyDefinition pAss) =>
{
//we do the array fuckery here to get the ref result out
object[] args = { pAss };
patcher.Invoke(null, args);
pAss = (AssemblyDefinition)args[0];
};
sortedPatchers.Add($"{ass.GetName().Name}/{type.FullName}", patcherPlugin);
}
catch (Exception e)
{
Logger.LogError($"Failed to load patcher [{patcherPlugin.TypeName}]: {e.Message}");
if (e is ReflectionTypeLoadException re)
Logger.LogDebug(TypeLoader.TypeLoadExceptionToString(re));
else
Logger.LogDebug(e.ToString());
}
}
Logger.Log(patcherCollection.Any() ? LogLevel.Info : LogLevel.Debug,
$"Loaded {patcherCollection.Count} patcher methods from {ass.GetName().FullName}");
}
foreach (KeyValuePair patcher in sortedPatchers)
AddPatcher(patcher.Value);
}
private static void InitializePatchers()
{
foreach (var assemblyPatcher in PatcherPlugins)
assemblyPatcher.Initializer?.Invoke();
}
private static void FinalizePatching()
{
foreach (var assemblyPatcher in PatcherPlugins)
assemblyPatcher.Finalizer?.Invoke();
}
///
/// Releases all patchers to let them be collected by GC.
///
public static void DisposePatchers()
{
PatcherPlugins.Clear();
}
///
/// Applies patchers to all assemblies in the given directory and loads patched assemblies into memory.
///
/// Directory to load CLR assemblies from.
public static void PatchAndLoad(string directory)
{
// First, load patchable assemblies into Cecil
var assemblies = new Dictionary();
foreach (string assemblyPath in Directory.GetFiles(directory, "*.dll"))
{
var assembly = AssemblyDefinition.ReadAssembly(assemblyPath);
//NOTE: this is special cased here because the dependency handling for System.dll is a bit wonky
//System has an assembly reference to itself, and it also has a reference to Mono.Security causing a circular dependency
//It's also generally dangerous to change system.dll since so many things rely on it,
// and it's already loaded into the appdomain since this loader references it, so we might as well skip it
if (assembly.Name.Name == "System" || assembly.Name.Name == "mscorlib") //mscorlib is already loaded into the appdomain so it can't be patched
{
assembly.Dispose();
continue;
}
if (UnityPatches.AssemblyLocations.ContainsKey(assembly.FullName))
{
Logger.LogWarning($"Tried to load duplicate assembly {Path.GetFileName(assemblyPath)} from Managed folder! Skipping...");
continue;
}
assemblies.Add(Path.GetFileName(assemblyPath), assembly);
UnityPatches.AssemblyLocations.Add(assembly.FullName, Path.GetFullPath(assemblyPath));
}
// Next, initialize all the patchers
InitializePatchers();
// Then, perform the actual patching
var patchedAssemblies = new HashSet();
foreach (var assemblyPatcher in PatcherPlugins)
foreach (string targetDll in assemblyPatcher.TargetDLLs())
if (assemblies.TryGetValue(targetDll, out var assembly))
{
if (AppDomain.CurrentDomain.GetAssemblies().Any(x => x.GetName().Name == assembly.Name.Name))
Logger.LogWarning($"Trying to patch an already loaded assembly [{assembly.Name.Name}] with [{assemblyPatcher.TypeName}]");
Logger.LogInfo($"Patching [{assembly.Name.Name}] with [{assemblyPatcher.TypeName}]");
assemblyPatcher.Patcher?.Invoke(ref assembly);
assemblies[targetDll] = assembly;
patchedAssemblies.Add(targetDll);
}
// Finally, load patched assemblies into memory
if (ConfigDumpAssemblies.Value || ConfigLoadDumpedAssemblies.Value)
{
if (!Directory.Exists(DumpedAssembliesPath))
Directory.CreateDirectory(DumpedAssembliesPath);
foreach (KeyValuePair kv in assemblies)
{
string filename = kv.Key;
var assembly = kv.Value;
if (patchedAssemblies.Contains(filename))
assembly.Write(Path.Combine(DumpedAssembliesPath, filename));
}
}
if (ConfigBreakBeforeLoadAssemblies.Value)
{
Logger.LogInfo($"BepInEx is about load the following assemblies:\n{String.Join("\n", patchedAssemblies.ToArray())}");
Logger.LogInfo($"The assemblies were dumped into {DumpedAssembliesPath}");
Logger.LogInfo("Load any assemblies into the debugger, set breakpoints and continue execution.");
Debugger.Break();
}
foreach (var kv in assemblies)
{
string filename = kv.Key;
var assembly = kv.Value;
// Note that since we only *load* assemblies, they shouldn't trigger dependency loading
// Not loading all assemblies is very important not only because of memory reasons,
// but because some games *rely* on that because of messed up internal dependencies.
if (patchedAssemblies.Contains(filename))
Load(assembly, filename);
// Though we have to dispose of all assemblies regardless of them being patched or not
assembly.Dispose();
}
//run all finalizers
FinalizePatching();
}
///
/// Loads an individual assembly definition into the CLR.
///
/// The assembly to load.
public static void Load(AssemblyDefinition assembly, string filename)
{
if (ConfigLoadDumpedAssemblies.Value)
Assembly.LoadFile(Path.Combine(DumpedAssembliesPath, filename));
else
using (var assemblyStream = new MemoryStream())
{
assembly.Write(assemblyStream);
Assembly.Load(assemblyStream.ToArray());
}
}
#region Config
private static readonly ConfigEntry ConfigDumpAssemblies = ConfigFile.CoreConfig.Bind(
"Preloader", "DumpAssemblies",
false,
"If enabled, BepInEx will save patched assemblies into BepInEx/DumpedAssemblies.\nThis can be used by developers to inspect and debug preloader patchers.");
private static readonly ConfigEntry ConfigLoadDumpedAssemblies = ConfigFile.CoreConfig.Bind(
"Preloader", "LoadDumpedAssemblies",
false,
"If enabled, BepInEx will load patched assemblies from BepInEx/DumpedAssemblies instead of memory.\nThis can be used to be able to load patched assemblies into debuggers like dnSpy.\nIf set to true, will override DumpAssemblies.");
private static readonly ConfigEntry ConfigBreakBeforeLoadAssemblies = ConfigFile.CoreConfig.Bind(
"Preloader", "BreakBeforeLoadAssemblies",
false,
"If enabled, BepInEx will call Debugger.Break() once before loading patched assemblies.\nThis can be used with debuggers like dnSpy to install breakpoints into patched assemblies before they are loaded.");
#endregion
}
}