void RefreshBodies(MemoryModuleDefFile file)
{
// Free all method bodies and clear cache so the new bodies are shown if any
// got modified (eg. decrypted in memory)
for (uint rid = 1; ; rid++)
{
var md = file.ModuleDef.ResolveToken(new MDToken(Table.Method, rid)) as MethodDef;
if (md == null)
{
break;
}
methodAnnotations.Value.SetBodyModified(md, false);
md.FreeMethodBody();
}
fileTabManager.RefreshModifiedFile(file);
// A breakpoint in an encrypted method will fail to be created. Now's a good time to
// re-add any failed breakpoints.
if (!file.Process.HasExited && file.Process.Debugger.ProcessState != DebuggerProcessState.Terminated)
{
foreach (var module in file.Process.Modules)
{
if (module.Address == file.Address)
{
file.Process.Debugger.AddBreakpoints(module);
}
}
}
}
public void UpdateModuleMemory(MemoryModuleDefFile file)
{
if (file.UpdateMemory())
{
RefreshBodies(file);
}
}
public static MemoryModuleDefFile CreateAssembly(List <MemoryModuleDefFile> files)
{
var manifest = files[0];
var file = new MemoryModuleDefFile(manifest.Process, manifest.Address, manifest.data, manifest.isInMemory, manifest.ModuleDef, false, manifest.AutoUpdateMemory);
file.files = new List <MemoryModuleDefFile>(files);
return(file);
}
MemoryModuleDefFile FindMemory(DnModule dnModule)
{
if (dnModule == null)
{
return(null);
}
var key = MemoryModuleDefFile.CreateKey(dnModule.Process, dnModule.Address);
return(AllMemoryModuleDefFiles.FirstOrDefault(a => key.Equals(a.Key)));
}
public Context(MemoryModuleDefFile file)
{
this.MemoryModuleDefFile = file;
}
void RefreshBodies(MemoryModuleDefFile file) {
// Free all method bodies and clear cache so the new bodies are shown if any
// got modified (eg. decrypted in memory)
for (uint rid = 1; ; rid++) {
var md = file.ModuleDef.ResolveToken(new MDToken(Table.Method, rid)) as MethodDef;
if (md == null)
break;
MethodAnnotations.Instance.SetBodyModified(md, false);
md.FreeMethodBody();
}
MainWindow.Instance.ModuleModified(file);
// A breakpoint in an encrypted method will fail to be created. Now's a good time to
// re-add any failed breakpoints.
if (!file.Process.HasExited && file.Process.Debugger.ProcessState != DebuggerProcessState.Terminated) {
foreach (var module in file.Process.Modules) {
if (module.Address == file.Address)
file.Process.Debugger.AddBreakpoints(module);
}
}
}
public void UpdateModuleMemory(MemoryModuleDefFile file) {
if (file.UpdateMemory())
RefreshBodies(file);
}
IDnSpyFile LoadFromMemory(DnModule dnModule, bool canLoadDynFile)
{
Debug.Assert(!dnModule.IsDynamic);
if (dnModule.Address == 0)
{
return(null);
}
var file = FindMemory(dnModule);
if (file != null)
{
return(file);
}
var manifestDnModule = dnModule.Assembly.Modules[0];
var manifestKey = MemoryModuleDefFile.CreateKey(manifestDnModule.Process, manifestDnModule.Address);
var manMod = FindAssemblyByKey(manifestKey);
Debug.Assert(manMod == null);
if (manMod != null)
{
return(null);
}
manMod = FindMemory(manifestDnModule);
Debug.Assert(manMod == null);
if (manMod != null)
{
return(null);
}
var modules = manifestDnModule.Assembly.Modules;
var dict = new Dictionary <ModuleDef, MemoryModuleDefFile>(modules.Length);
var files = new List <MemoryModuleDefFile>(modules.Length);
MemoryModuleDefFile result = null;
foreach (var module in modules)
{
MemoryModuleDefFile mfile;
try {
mfile = MemoryModuleDefFile.Create(module, UseDebugSymbols);
UpdateResolver(mfile.ModuleDef);
if (module == dnModule)
{
result = mfile;
}
}
catch {
// The PE headers and/or .NET headers are probably corrupt
return(LoadDynamic(dnModule, canLoadDynFile));
}
files.Add(mfile);
dict.Add(mfile.ModuleDef, mfile);
}
Debug.Assert(result != null);
if (files.Count == 0)
{
return(null);
}
var asmFile = MemoryModuleDefFile.CreateAssembly(files);
var asm = files[0].AssemblyDef;
if (asm == null)
{
if (files.Count > 1)
{
asm = files[0].ModuleDef.UpdateRowId(new AssemblyDefUser("???"));
asm.Modules.Add(files[0].ModuleDef);
}
}
asm.Modules.Clear();
for (int i = 0; i < files.Count; i++)
{
asm.Modules.Add(files[i].ModuleDef);
}
var addedFile = fileManager.GetOrAdd(asmFile);
Debug.Assert(addedFile == asmFile);
return(result);
}
void OnModuleAdded(DnModule module)
{
// If an assembly is visible in the treeview, and a new netmodule gets added, add a
// new netmodule node to the assembly in the treeview.
var manifestModule = module.Assembly.Modules[0];
// If it's the manifest module, it can't possibly have been inserted in the treeview already
if (manifestModule == module)
{
return;
}
// Update a dynamic assembly, if one exists
{
var manifestKey = CorModuleDefFile.CreateKey(manifestModule);
var asmFile = FindAssemblyByKey(manifestKey);
var asmNode = fileTreeView.FindNode(asmFile) as IAssemblyFileNode;
if (asmNode != null)
{
var cmdf = (CorModuleDefFile)asmNode.DnSpyFile;
var moduleKey = CorModuleDefFile.CreateKey(module);
asmNode.TreeNode.EnsureChildrenLoaded();
Debug.Assert(asmNode.TreeNode.Children.Count >= 1);
var moduleNode = asmNode.TreeNode.DataChildren.OfType <IModuleFileNode>().FirstOrDefault(a => moduleKey.Equals(a.DnSpyFile.Key));
Debug.Assert(moduleNode == null);
if (moduleNode == null)
{
var newFile = new CorModuleDefFile(module, UseDebugSymbols);
UpdateResolver(module.GetOrCreateCorModuleDef());
cmdf.Children.Add(newFile);
Initialize(module.Debugger, new[] { newFile.DnModule.CorModuleDef });
asmNode.TreeNode.Children.Add(fileTreeView.TreeView.Create(fileTreeView.CreateNode(asmNode, newFile)));
}
}
}
// Update an in-memory assembly, if one exists
if (manifestModule.Address != 0 && module.Address != 0)
{
var manifestKey = MemoryModuleDefFile.CreateKey(manifestModule.Process, manifestModule.Address);
var asmFile = FindAssemblyByKey(manifestKey);
var asmNode = fileTreeView.FindNode(asmFile) as IAssemblyFileNode;
if (asmNode != null)
{
var mmdf = (MemoryModuleDefFile)asmNode.DnSpyFile;
var moduleKey = MemoryModuleDefFile.CreateKey(module.Process, module.Address);
asmNode.TreeNode.EnsureChildrenLoaded();
Debug.Assert(asmNode.TreeNode.Children.Count >= 1);
var moduleNode = asmNode.TreeNode.DataChildren.OfType <IModuleFileNode>().FirstOrDefault(a => moduleKey.Equals(a.DnSpyFile.Key));
Debug.Assert(moduleNode == null);
if (moduleNode == null)
{
MemoryModuleDefFile newFile = null;
try {
newFile = MemoryModuleDefFile.Create(module, UseDebugSymbols);
}
catch {
}
Debug.Assert(newFile != null);
if (newFile != null)
{
UpdateResolver(newFile.ModuleDef);
mmdf.Children.Add(newFile);
asmNode.DnSpyFile.ModuleDef.Assembly.Modules.Add(newFile.ModuleDef);
asmNode.TreeNode.Children.Add(fileTreeView.TreeView.Create(fileTreeView.CreateNode(asmNode, newFile)));
}
}
}
}
}
public static MemoryModuleDefFile CreateAssembly(List<MemoryModuleDefFile> files) {
var manifest = files[0];
var file = new MemoryModuleDefFile(manifest.Process, manifest.Address, manifest.data, manifest.isInMemory, manifest.module, false, manifest.AutoUpdateMemory);
file.files = new List<MemoryModuleDefFile>(files);
return file;
}
