/// <summary> /// Creates an <see cref="AssemblyDef"/> instance from a stream /// </summary> /// <remarks>This will read all bytes from the stream and call <see cref="Load(byte[],ModuleContext)"/>. /// It's better to use one of the other Load() methods.</remarks> /// <param name="stream">The stream</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="AssemblyDef"/> instance</returns> /// <exception cref="ArgumentNullException">If <paramref name="stream"/> is <c>null</c></exception> /// <exception cref="BadImageFormatException">If it's not a .NET assembly (eg. not a .NET file or only a .NET module)</exception> public static AssemblyDef Load(Stream stream, ModuleCreationOptions options) { if (stream == null) { throw new ArgumentNullException("stream"); } ModuleDef module = null; try { module = ModuleDefMD.Load(stream, options); var asm = module.Assembly; if (asm == null) { throw new BadImageFormatException(string.Format("{0} is only a .NET module, not a .NET assembly. Use ModuleDef.Load().", module.ToString())); } return(asm); } catch { if (module != null) { module.Dispose(); } throw; } }
/// <summary> /// Creates an <see cref="AssemblyDef"/> instance from a memory location /// </summary> /// <param name="addr">Address of a .NET assembly</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="AssemblyDef"/> instance</returns> /// <exception cref="ArgumentNullException">If <paramref name="addr"/> is <c>null</c></exception> /// <exception cref="BadImageFormatException">If it's not a .NET assembly (eg. not a .NET file or only a .NET module)</exception> public static AssemblyDef Load(IntPtr addr, ModuleCreationOptions options) { if (addr == IntPtr.Zero) { throw new ArgumentNullException("addr"); } ModuleDef module = null; try { module = ModuleDefMD.Load(addr, options); var asm = module.Assembly; if (asm == null) { throw new BadImageFormatException(string.Format("{0} (addr: {1:X8}) is only a .NET module, not a .NET assembly. Use ModuleDef.Load().", module.ToString(), addr.ToInt64())); } return(asm); } catch { if (module != null) { module.Dispose(); } throw; } }
/// <summary> /// Creates an <see cref="AssemblyDef"/> instance from a file /// </summary> /// <param name="fileName">File name of an existing .NET assembly</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="AssemblyDef"/> instance</returns> /// <exception cref="ArgumentNullException">If <paramref name="fileName"/> is <c>null</c></exception> /// <exception cref="BadImageFormatException">If it's not a .NET assembly (eg. not a .NET file or only a .NET module)</exception> public static AssemblyDef Load(string fileName, ModuleCreationOptions options) { if (fileName == null) throw new ArgumentNullException("fileName"); ModuleDef module = null; try { module = ModuleDefMD.Load(fileName, options); var asm = module.Assembly; if (asm == null) throw new BadImageFormatException(string.Format("{0} is only a .NET module, not a .NET assembly. Use ModuleDef.Load().", fileName)); return asm; } catch { if (module != null) module.Dispose(); throw; } }
/// <summary> /// Creates an <see cref="AssemblyDef"/> instance from a byte[] /// </summary> /// <param name="data">Contents of a .NET assembly</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="AssemblyDef"/> instance</returns> /// <exception cref="ArgumentNullException">If <paramref name="data"/> is <c>null</c></exception> /// <exception cref="BadImageFormatException">If it's not a .NET assembly (eg. not a .NET file or only a .NET module)</exception> public static AssemblyDef Load(byte[] data, ModuleCreationOptions options) { if (data == null) throw new ArgumentNullException("data"); ModuleDef module = null; try { module = ModuleDefMD.Load(data, options); var asm = module.Assembly; if (asm == null) throw new BadImageFormatException(string.Format("{0} is only a .NET module, not a .NET assembly. Use ModuleDef.Load().", module.ToString())); return asm; } catch { if (module != null) module.Dispose(); throw; } }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a memory location /// </summary> /// <param name="addr">Address of a .NET module/assembly</param> /// <param name="options">Module creation options or <c>null</c></param> /// <param name="imageLayout">Image layout of the file in memory</param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(IntPtr addr, ModuleCreationOptions options, ImageLayout imageLayout) { return Load(MetaDataCreator.Load(addr, imageLayout), options); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance /// </summary> /// <param name="peImage">PE image</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(IPEImage peImage, ModuleCreationOptions options) { return Load(MetaDataCreator.Load(peImage), options); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a memory location /// </summary> /// <param name="addr">Address of a .NET module/assembly</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(IntPtr addr, ModuleCreationOptions options) { return Load(MetaDataCreator.Load(addr), options); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a reflection module /// </summary> /// <param name="mod">An existing reflection module</param> /// <param name="options">Module creation options or <c>null</c></param> /// <param name="imageLayout">Image layout of the module in memory</param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(System.Reflection.Module mod, ModuleCreationOptions options, ImageLayout imageLayout) { IntPtr addr = Marshal.GetHINSTANCE(mod); if (addr == new IntPtr(-1)) throw new InvalidOperationException(string.Format("Module {0} has no HINSTANCE", mod)); return Load(addr, options, imageLayout); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a reflection module /// </summary> /// <param name="mod">An existing reflection module</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(System.Reflection.Module mod, ModuleCreationOptions options) { return Load(mod, options, GetImageLayout(mod)); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a reflection module /// </summary> /// <param name="mod">An existing reflection module</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(System.Reflection.Module mod, ModuleCreationOptions options) { return Load(mod, options, GetImageLayout(mod)); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a file /// </summary> /// <param name="fileName">File name of an existing .NET module/assembly</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(string fileName, ModuleCreationOptions options = null) { return Load(MetaDataCreator.Load(fileName), options); }
ISymbolReader CreateSymbolReader(ModuleCreationOptions options) { if (options.CreateSymbolReader != null) { var symReader = options.CreateSymbolReader(this); if (symReader != null) return symReader; } if (options.PdbFileOrData != null) { var pdbFileName = options.PdbFileOrData as string; if (!string.IsNullOrEmpty(pdbFileName)) { var symReader = SymbolReaderCreator.Create(options.PdbImplementation, metaData, pdbFileName); if (symReader != null) return symReader; } var pdbData = options.PdbFileOrData as byte[]; if (pdbData != null) return SymbolReaderCreator.Create(options.PdbImplementation, metaData, pdbData); var pdbStream = options.PdbFileOrData as IImageStream; if (pdbStream != null) return SymbolReaderCreator.Create(options.PdbImplementation, metaData, pdbStream); } if (options.TryToLoadPdbFromDisk && !string.IsNullOrEmpty(location)) return SymbolReaderCreator.Create(options.PdbImplementation, location); return null; }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a <see cref="MetaData"/> /// </summary> /// <param name="metaData">The metadata</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="ModuleDefMD"/> instance that now owns <paramref name="metaData"/></returns> internal static ModuleDefMD Load(MetaData metaData, ModuleCreationOptions options) { return new ModuleDefMD(metaData, options); }
LoadedFile LoadAssembly(object state) { IPEImage peImage; if (OtherSettings.Instance.UseMemoryMappedIO) peImage = new PEImage(fileName); else peImage = new PEImage(File.ReadAllBytes(fileName)); var dotNetDir = peImage.ImageNTHeaders.OptionalHeader.DataDirectories[14]; bool isDotNet = dotNetDir.VirtualAddress != 0 && dotNetDir.Size >= 0x48; if (isDotNet) { try { ModuleDef module; var opts = new ModuleCreationOptions(CreateModuleContext()); if (OtherSettings.Instance.UseMemoryMappedIO) module = ModuleDefMD.Load(peImage, opts); else module = ModuleDefMD.Load(peImage, opts); return InitializeModule(module); } catch { } } return new LoadedFile(peImage, null); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a stream /// </summary> /// <remarks>This will read all bytes from the stream and call <see cref="Load(byte[],ModuleContext)"/>. /// It's better to use one of the other Load() methods.</remarks> /// <param name="stream">The stream (owned by caller)</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> /// <exception cref="ArgumentNullException">If <paramref name="stream"/> is <c>null</c></exception> public static ModuleDefMD Load(Stream stream, ModuleCreationOptions options) { if (stream == null) throw new ArgumentNullException("stream"); if (stream.Length > int.MaxValue) throw new ArgumentException("Stream is too big"); var data = new byte[(int)stream.Length]; stream.Position = 0; if (stream.Read(data, 0, data.Length) != data.Length) throw new IOException("Could not read all bytes from the stream"); return Load(data, options); }
/// <summary> /// Constructor /// </summary> /// <param name="metaData">The metadata</param> /// <param name="options">Module creation options or <c>null</c></param> /// <exception cref="ArgumentNullException">If <paramref name="metaData"/> is <c>null</c></exception> ModuleDefMD(MetaData metaData, ModuleCreationOptions options) : base(null, 1) { #if DEBUG if (metaData == null) throw new ArgumentNullException("metaData"); #endif if (options == null) options = ModuleCreationOptions.Default; this.metaData = metaData; this.context = options.Context; Initialize(); InitializeFromRawRow(); location = metaData.PEImage.FileName ?? string.Empty; this.Kind = GetKind(); this.Characteristics = MetaData.PEImage.ImageNTHeaders.FileHeader.Characteristics; this.DllCharacteristics = MetaData.PEImage.ImageNTHeaders.OptionalHeader.DllCharacteristics; this.RuntimeVersion = MetaData.VersionString; this.Machine = MetaData.PEImage.ImageNTHeaders.FileHeader.Machine; this.Cor20HeaderFlags = MetaData.ImageCor20Header.Flags; this.Cor20HeaderRuntimeVersion = (uint)(MetaData.ImageCor20Header.MajorRuntimeVersion << 16) | MetaData.ImageCor20Header.MinorRuntimeVersion; this.TablesHeaderVersion = MetaData.TablesStream.Version; corLibTypes = new CorLibTypes(this, options.CorLibAssemblyRef ?? FindCorLibAssemblyRef() ?? CreateDefaultCorLibAssemblyRef()); InitializePdb(options); }
void InitializePdb(ModuleCreationOptions options) { if (options == null) return; LoadPdb(CreateSymbolReader(options)); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a byte[] /// </summary> /// <param name="data">Contents of a .NET module/assembly</param> /// <param name="options">Module creation options or <c>null</c></param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(byte[] data, ModuleCreationOptions options = null) { return Load(MetaDataCreator.Load(data), options); }
/// <summary> /// Creates a <see cref="ModuleDefMD"/> instance from a reflection module /// </summary> /// <param name="mod">An existing reflection module</param> /// <param name="options">Module creation options or <c>null</c></param> /// <param name="imageLayout">Image layout of the module in memory</param> /// <returns>A new <see cref="ModuleDefMD"/> instance</returns> public static ModuleDefMD Load(System.Reflection.Module mod, ModuleCreationOptions options, ImageLayout imageLayout) { IntPtr addr = Marshal.GetHINSTANCE(mod); if (addr == new IntPtr(-1)) throw new InvalidOperationException(string.Format("Module {0} has no HINSTANCE", mod)); return Load(addr, options, imageLayout); }