IDsDocument?TryRuntimeAssemblyResolvers(IAssembly assembly, ModuleDef?sourceModule)
{
foreach (var lz in runtimeAsmResolvers)
{
var result = lz.Value.Resolve(assembly, sourceModule);
if (!result.IsDefault)
{
if (!string2.IsNullOrEmpty(result.Filename))
{
var file = documentService.Find(FilenameKey.CreateFullPath(result.Filename), checkTempCache: true);
if (file is not null)
{
return(file);
}
}
if (result.GetFileData is not null)
{
return(documentService.TryGetOrCreateInternal(DsDocumentInfo.CreateInMemory(result.GetFileData, result.Filename), true, true));
}
if (!string2.IsNullOrEmpty(result.Filename))
{
return(documentService.TryGetOrCreateInternal(DsDocumentInfo.CreateDocument(result.Filename), true, true));
}
Debug.Fail("Shouldn't be reached");
return(null);
}
}
return(null);
}
static ModuleDef CreateModuleDef(string name, Guid mvid, ClrVersion clrVersion, ModuleDef?existingModule)
{
var clrValues = ClrVersionValues.GetValues(clrVersion);
if (clrValues is null)
{
throw new ArgumentNullException(nameof(clrVersion));
}
ModuleDef module;
if (existingModule is null)
{
module = new ModuleDefUser(name, mvid, clrValues.CorLibRef);
}
else
{
module = existingModule;
module.Name = name;
module.Mvid = mvid;
OverwriteAssembly(module.CorLibTypes.AssemblyRef, clrValues.CorLibRef);
}
module.UpdateRowId(module);
module.RuntimeVersion = clrValues.RuntimeVersion;
module.Cor20HeaderRuntimeVersion = clrValues.Cor20HeaderRuntimeVersion;
module.TablesHeaderVersion = clrValues.TablesHeaderVersion;
module.Location = string.Empty;
return(module);
}
IDsDocument?Resolve(IAssembly assembly, ModuleDef?sourceModule)
{
if (assembly.IsContentTypeWindowsRuntime)
{
if (failedAssemblyResolveCache.IsFailed(assembly))
{
return(null);
}
var document = ResolveWinMD(assembly, sourceModule);
if (document is null)
{
failedAssemblyResolveCache.MarkFailed(assembly);
}
return(document);
}
else
{
if (failedAssemblyResolveCache.IsFailed(assembly))
{
return(null);
}
var document = ResolveNormal(assembly, sourceModule);
if (document is null)
{
failedAssemblyResolveCache.MarkFailed(assembly);
}
return(document);
}
}
// Priority order: 1) active in-memory/dynamic module, 2) active module, 3) other module
ModuleDef?LoadExisting(ModuleId moduleId)
{
ModuleDef?foundModule = null;
ModuleDef?activeModule = null;
foreach (var info in dsDocumentProvider.DocumentInfos)
{
if (info.Id != moduleId)
{
continue;
}
if (info.IsActive)
{
if (info.Document is MemoryModuleDefDocument || info.Document is DynamicModuleDefDocument)
{
return(info.Document.ModuleDef);
}
activeModule ??= info.Document.ModuleDef;
}
else
{
foundModule ??= info.Document.ModuleDef;
}
}
return(activeModule ?? foundModule);
}
/// <summary>
/// Checks whether the type matches an expected type
/// </summary>
/// <param name="module">Module</param>
/// <param name="name">Type name</param>
/// <param name="expectedType">Expected type</param>
/// <returns></returns>
public static bool CheckType(ModuleDef?module, string name, TypeRef expectedType)
{
if (module is null)
{
module = new ModuleDefUser();
}
var tr = TypeNameParser.ParseReflection(module, name, null);
if (tr is null)
{
return(false);
}
var flags = AssemblyNameComparerFlags.All & ~AssemblyNameComparerFlags.Version;
if (!new AssemblyNameComparer(flags).Equals(tr.DefinitionAssembly, expectedType.DefinitionAssembly))
{
return(false);
}
if (!new SigComparer().Equals(tr, expectedType))
{
return(false);
}
return(true);
}
/// <summary>
/// Gets the image data
/// </summary>
/// <param name="module">Module</param>
/// <param name="typeName">Name of type</param>
/// <param name="serializedData">Serialized data</param>
/// <param name="imageData">Updated with image data</param>
/// <returns></returns>
public static bool GetImageData(ModuleDef?module, string typeName, byte[] serializedData, [NotNullWhen(true)] out byte[]?imageData)
{
imageData = null;
if (!SerializedImageUtilities.CheckType(module, typeName, SystemWindowsFormsImageListStreamer))
{
return(false);
}
var dict = Deserializer.Deserialize(SystemWindowsFormsImageListStreamer.DefinitionAssembly.FullName, SystemWindowsFormsImageListStreamer.ReflectionFullName, serializedData);
// ImageListStreamer loops over every item looking for "Data" (case insensitive)
foreach (var v in dict.Values)
{
var d = v.Value as byte[];
if (d is null)
{
continue;
}
if ("Data".Equals(v.Name, StringComparison.OrdinalIgnoreCase))
{
imageData = d;
return(true);
}
}
return(false);
}
static IEnumerable <ModuleDef> GetModules(AssemblyDef?assembly, ModuleDef?module)
{
if (!(assembly is null))
{
foreach (var mod in assembly.Modules)
{
yield return(mod);
}
}
/// <summary>
/// Converts an RVA to a file offset
/// </summary>
/// <param name="module">Module</param>
/// <param name="rva">RVA</param>
/// <returns></returns>
public static uint?ToFileOffset(this ModuleDef?module, uint rva)
{
var m = module as ModuleDefMD; //TODO: Support CorModuleDef
if (m is null)
{
return(null);
}
return((uint)m.Metadata.PEImage.ToFileOffset((RVA)rva));
}
public void Finish()
{
if (this.targetType is not null)
{
ModuleDef?module = this.targetType.Module;
module.Types.Remove(this.targetType);
module.Types[0] = this.targetType;
this.targetType.IsAbstract = this.targetType.IsSealed = this.targetType.IsBeforeFieldInit = false;
this.targetType.BaseType = null;
}
}
internal static bool CanIncludeModule(ModuleDef targetModule, ModuleDef?module)
{
if (module is null)
{
return(false);
}
if (targetModule == module)
{
return(false);
}
if (!(targetModule.Assembly is null) && targetModule.Assembly == module.Assembly)
{
return(false);
}
return(true);
}
static IEnumerable <TypeDef> GetTypeEquivalentTypes(AssemblyDef?assembly, ModuleDef?module, TypeDef type)
{
Debug.Assert(TIAHelper.IsTypeDefEquivalent(type));
var typeRef = new ModuleDefUser("dummy").Import(type);
foreach (var mod in GetModules(assembly, module))
{
var otherType = mod.Find(typeRef);
if (otherType != type && TIAHelper.IsTypeDefEquivalent(otherType) &&
new SigComparer().Equals(otherType, type) &&
!new SigComparer(SigComparerOptions.DontCheckTypeEquivalence).Equals(otherType, type))
{
yield return(otherType);
}
}
}
public IDsDocument?Resolve(IAssembly asm, ModuleDef?sourceModule)
{
var document = FindAssembly(asm);
if (document is not null)
{
return(document);
}
var asmDef = AssemblyResolver.Resolve(asm, sourceModule);
if (asmDef is not null)
{
return(FindAssembly(asm));
}
return(null);
}
public ModuleId Create(ModuleDef?module)
{
if (module is null)
{
return(new ModuleId());
}
var res = moduleDictionary.GetValue(module, callbackCreateCore).Value;
// Don't cache dynamic modules. The reason is that their ModuleIds could change,
// see CorDebug's DbgEngineImpl.UpdateDynamicModuleIds()
if (res.IsDynamic)
{
return(CreateCore(module).Value);
}
return(res);
}
MethodDef?GetMetadataMethod(DisasmInfo method)
{
if (!StringComparer.OrdinalIgnoreCase.Equals(lastModule?.Location, method.ModuleFilename))
{
lastModule = metadataProvider.GetModule(method.ModuleFilename);
lastMethod = null;
}
if (lastModule?.PdbState is null)
{
return(null);
}
if (lastMethod?.MDToken.Raw != method.MethodToken)
{
lastMethod = lastModule?.ResolveToken(method.MethodToken) as MethodDef;
}
return(lastMethod);
}
/// <summary>
/// Checks whether the data can be updated
/// </summary>
/// <param name="module">Module</param>
/// <param name="newResElem">New data</param>
/// <returns></returns>
public static string CheckCanUpdateData(ModuleDef?module, ResourceElement newResElem)
{
var binData = (BinaryResourceData)newResElem.ResourceData;
if (!GetImageData(module, binData.TypeName, binData.Data, out var imageData))
{
return(dnSpy_Contracts_DnSpy_Resources.NewDataNotImageList);
}
try {
ReadImageData(imageData);
}
catch {
return(dnSpy_Contracts_DnSpy_Resources.NewDataNotImageList);
}
return(string.Empty);
}
/// <summary>
/// Gets the image data
/// </summary>
/// <param name="module">Module</param>
/// <param name="typeName">Name of type</param>
/// <param name="serializedData">Serialized data</param>
/// <param name="imageData">Updated with the image data</param>
/// <returns></returns>
public static bool GetImageData(ModuleDef?module, string typeName, byte[] serializedData, [NotNullWhen(true)] out byte[]?imageData)
{
imageData = null;
if (CouldBeBitmap(module, typeName))
{
var dict = Deserializer.Deserialize(SystemDrawingBitmap.DefinitionAssembly.FullName, SystemDrawingBitmap.ReflectionFullName, serializedData);
// Bitmap loops over every item looking for "Data" (case insensitive)
foreach (var v in dict.Values)
{
var d = v.Value as byte[];
if (d is null)
{
continue;
}
if ("Data".Equals(v.Name, StringComparison.OrdinalIgnoreCase))
{
imageData = d;
return(true);
}
}
return(false);
}
if (CouldBeIcon(module, typeName))
{
var dict = Deserializer.Deserialize(SystemDrawingIcon.DefinitionAssembly.FullName, SystemDrawingIcon.ReflectionFullName, serializedData);
if (!dict.TryGetValue("IconData", out var info))
{
return(false);
}
imageData = info.Value as byte[];
return(!(imageData is null));
}
return(false);
}
object?GetEntryPoint(ModuleDef?module)
{
int maxIters = 1;
for (int i = 0; module is not null && i < maxIters; i++)
{
var rva = module.NativeEntryPoint;
if (rva != 0)
{
return((uint)rva);
}
var manEp = module.ManagedEntryPoint;
if (manEp is MethodDef ep)
{
return(ep);
}
var file = manEp as FileDef;
if (file is null)
{
return(null);
}
var asm = module.Assembly;
if (asm is null)
{
return(null);
}
maxIters = asm.Modules.Count;
module = asm.Modules.FirstOrDefault(m => File.Exists(m.Location) && StringComparer.OrdinalIgnoreCase.Equals(Path.GetFileName(m.Location), file.Name));
}
return(null);
}
FrameworkKind GetFrameworkKind(ModuleDef?module, out Version?netVersion, out string?sourceModuleDirectoryHint)
{
if (module is null)
{
netVersion = null;
sourceModuleDirectoryHint = null;
return(FrameworkKind.Unknown);
}
var sourceFilename = module.Location;
if (!string2.IsNullOrEmpty(sourceFilename))
{
bool isExe = (module.Characteristics & Characteristics.Dll) == 0;
Version?fwkVersion;
foreach (var info in frameworkInfos)
{
if (FileUtils.IsFileInDir(info.Directory, sourceFilename))
{
// The same 'module' could be passed in here multiple times, but we can't save the module instance
// anywhere so only update info if it's an EXE and then mark it as frozen.
if (isExe && !info.Frozen)
{
info.Frozen = true;
var newFwkKind = GetFrameworkKind_TargetFrameworkAttribute(module, out var frameworkName, out fwkVersion);
if (newFwkKind == FrameworkKind.Unknown)
{
newFwkKind = GetFrameworkKind_AssemblyRefs(module, frameworkName, out fwkVersion);
}
if (newFwkKind != FrameworkKind.Unknown)
{
info.FrameworkKind = Best(info.FrameworkKind, newFwkKind);
if (info.FrameworkKind == FrameworkKind.DotNet && newFwkKind == FrameworkKind.DotNet)
{
info.FrameworkVersion = fwkVersion;
}
}
}
if (info.FrameworkKind == FrameworkKind.DotNet)
{
netVersion = info.FrameworkVersion;
}
else
{
netVersion = null;
}
sourceModuleDirectoryHint = info.Directory;
return(info.FrameworkKind);
}
}
var fwkKind = GetRuntimeFrameworkKind(sourceFilename, out var frameworkVersion);
if (fwkKind != FrameworkKind.Unknown)
{
if (fwkKind == FrameworkKind.DotNet)
{
netVersion = frameworkVersion;
}
else
{
netVersion = null;
}
sourceModuleDirectoryHint = null;
return(fwkKind);
}
var fwkInfo = new FrameworkPathInfo(Path.GetDirectoryName(sourceFilename) !);
fwkInfo.FrameworkKind = GetFrameworkKind_Directory(fwkInfo.Directory, out fwkVersion);
fwkInfo.FrameworkVersion = fwkVersion;
if (fwkInfo.FrameworkKind == FrameworkKind.Unknown)
{
fwkInfo.FrameworkKind = GetFrameworkKind_TargetFrameworkAttribute(module, out var frameworkName, out fwkVersion);
fwkInfo.FrameworkVersion = fwkVersion;
if (fwkInfo.FrameworkKind == FrameworkKind.Unknown)
{
fwkInfo.FrameworkKind = GetFrameworkKind_AssemblyRefs(module, frameworkName, out fwkVersion);
fwkInfo.FrameworkVersion = fwkVersion;
}
}
if (fwkInfo.FrameworkKind == FrameworkKind.Unknown)
{
fwkInfo.FrameworkVersion = null;
}
fwkInfo.Frozen = isExe;
fwkInfo = Add(fwkInfo);
if (fwkInfo.FrameworkKind == FrameworkKind.DotNet)
{
netVersion = fwkInfo.FrameworkVersion;
}
else
{
netVersion = null;
}
sourceModuleDirectoryHint = fwkInfo.Directory;
return(fwkInfo.FrameworkKind);
}
netVersion = null;
sourceModuleDirectoryHint = null;
return(FrameworkKind.Unknown);
}
public void Dispose()
{
lastModule = null;
lastMethod = null;
}
static bool IsExe(ModuleDef?mod) => mod is not null && (mod.Characteristics & Characteristics.Dll) == 0;
static bool CouldBeIcon(ModuleDef?module, string name) => CheckType(module, name, SystemDrawingIcon);
static bool CouldBeBitmap(ModuleDef?module, string name) => CheckType(module, name, SystemDrawingBitmap);
BuilderState CreateAstBuilder(DecompilationContext ctx, DecompilerSettings settings, ModuleDef?currentModule = null, TypeDef?currentType = null, bool isSingleMember = false)
{
if (currentModule is null)
{
currentModule = currentType?.Module;
}
settings = settings.Clone();
if (isSingleMember)
{
settings.UsingDeclarations = false;
}
settings.IntroduceIncrementAndDecrement = false;
settings.MakeAssignmentExpressions = false;
settings.QueryExpressions = false;
settings.AlwaysGenerateExceptionVariableForCatchBlocksUnlessTypeIsObject = true;
var cache = ctx.GetOrCreate(createBuilderCache);
var state = new BuilderState(ctx, cache, MetadataTextColorProvider);
state.AstBuilder.Context.CurrentModule = currentModule;
state.AstBuilder.Context.CancellationToken = ctx.CancellationToken;
state.AstBuilder.Context.CurrentType = currentType;
state.AstBuilder.Context.Settings = settings;
return(state);
}
public static ModuleDef CreateModule(string name, Guid mvid, ClrVersion clrVersion, ModuleKind kind, ModuleDef?existingModule = null)
{
var module = CreateModuleDef(name, mvid, clrVersion, existingModule);
module.Kind = kind;
module.Characteristics = Characteristics.Bit32Machine | Characteristics.ExecutableImage;
if (kind == ModuleKind.Dll || kind == ModuleKind.NetModule)
{
module.Characteristics |= Characteristics.Dll;
}
module.DllCharacteristics = DllCharacteristics.TerminalServerAware | DllCharacteristics.NoSeh | DllCharacteristics.NxCompat | DllCharacteristics.DynamicBase;
return(module);
}
AssemblyDef?IAssemblyResolver.Resolve(IAssembly assembly, ModuleDef?sourceModule) => Resolve(assembly, sourceModule)?.AssemblyDef;
public static void Main(String?[]?args)
{
if (args is null || args.Length == 0)
{
Console.WriteLine("Invalid arguments");
return;
}
String?path = args[0];
if (path.IsNullOrWhiteSpace())
{
Console.WriteLine("Empty path provided");
return;
}
var file = new FileInfo(path);
if (!file.Exists)
{
Console.WriteLine("No file found");
return;
}
ModuleContext ctx = ModuleDef.CreateModuleContext();
AssemblyDef? asm;
try
{
Byte[]? b = File.ReadAllBytes(file.FullName);
asm = AssemblyDef.Load(b, ctx);
} catch
{
Console.WriteLine("Error loading assembly");
return;
}
if (asm is null)
{
Console.WriteLine("Error loading assembly");
return;
}
String?loc = Assembly.GetExecutingAssembly().Location;
if (!loc.IsNullOrWhiteSpace())
{
var f = new FileInfo(loc);
LoadAssemblies(f.Directory.CreateSubdirectory("Extensions"));
}
for (Int32 i = 1; i < args.Length; ++i)
{
LoadAssemblies(new DirectoryInfo(args[i]));
}
if (PatchEntry.PatchAssembly(asm, ctx, new Logger()))
{
Console.WriteLine("Patch success, saving");
var opt = new ModuleWriterOptions(asm.ManifestModule);
asm.Write(path, opt);
for (Int32 i = 0; i < asm.Modules.Count; ++i)
{
ModuleDef?mod = asm.Modules[i];
if (mod.IsManifestModule)
{
continue;
}
var subOpt = new ModuleWriterOptions(mod);
mod.Write(path + mod.FullName + ".netmodule", subOpt);
}
}
else
{
Console.WriteLine("Patch failed, will not save");
}
}
RuntimeAssemblyResolverResult IRuntimeAssemblyResolver.Resolve(IAssembly assembly, ModuleDef?sourceModule)
{
if (dbgManager is null || !dbgManager.IsDebugging)
{
return(default);