/// <summary>
/// Constructor
/// </summary>
/// <param name="imageStream">Heap stream</param>
/// <param name="streamHeader">Stream header info</param>
/// <param name="fullStream">Stream for the full PE file</param>
/// <param name="baseOffset">Offset in <paramref name="fullStream" /> where the data starts</param>
protected HotStream(IImageStream imageStream, StreamHeader streamHeader, IImageStream fullStream, FileOffset baseOffset)
: base(imageStream, streamHeader)
{
this.fullStream = fullStream;
this.baseOffset = (long)baseOffset;
endOffset = (long)baseOffset + imageStream.Length;
}
/// <summary>
/// Creates a <see cref="HotStream"/> instance
/// </summary>
/// <param name="version">Hot heap version</param>
/// <param name="imageStream">Heap stream</param>
/// <param name="streamHeader">Stream header info</param>
/// <param name="fullStream">Stream for the full PE file</param>
/// <param name="baseOffset">Offset in <paramref name="fullStream"/> where the data starts</param>
/// <returns>A <see cref="HotStream"/> instance or <c>null</c> if <paramref name="version"/>
/// is invalid</returns>
public static HotStream Create(HotHeapVersion version, IImageStream imageStream, StreamHeader streamHeader, IImageStream fullStream, FileOffset baseOffset) {
switch (version) {
case HotHeapVersion.CLR20: return new HotStreamCLR20(imageStream, streamHeader, fullStream, baseOffset);
case HotHeapVersion.CLR40: return new HotStreamCLR40(imageStream, streamHeader, fullStream, baseOffset);
default: return null;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="reader">PE file reader pointing to the start of this section</param>
/// <param name="verify">Verify section</param>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
public MetaDataHeader(IImageStream reader, bool verify)
{
SetStartOffset(reader);
//Interaction.MsgBox(reader.Position);
this.signature = reader.ReadUInt32();
if (verify && this.signature != 0x424A5342)
{
throw new BadImageFormatException("Invalid MetaData header signature");
}
this.majorVersion = reader.ReadUInt16();
this.minorVersion = reader.ReadUInt16();
if (verify && !((majorVersion == 1 && minorVersion == 1) || (majorVersion == 0 && minorVersion >= 19)))
{
throw new BadImageFormatException(string.Format("Unknown MetaData header version: {0}.{1}", majorVersion, minorVersion));
}
this.reserved1 = reader.ReadUInt32();
this.stringLength = reader.ReadUInt32();
this.versionString = ReadString(reader, stringLength);
this.offset2ndPart = reader.FileOffset + reader.Position;
this.flags = (StorageFlags)reader.ReadByte();
this.reserved2 = reader.ReadByte();
this.streams = reader.ReadUInt16();
this.streamHeaders = new StreamHeader[streams];
for (int i = 0; i < streamHeaders.Count; i++)
{
streamHeaders[i] = new StreamHeader(reader, verify);
}
SetEndoffset(reader);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="reader">PE file reader pointing to the start of this section</param>
/// <param name="verify">Verify section</param>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
public MetaDataHeader(IImageStream reader, bool verify)
{
SetStartOffset(reader);
Signature = reader.ReadUInt32();
if (verify && Signature != 0x424A5342)
{
throw new BadImageFormatException("Invalid MetaData header signature");
}
MajorVersion = reader.ReadUInt16();
MinorVersion = reader.ReadUInt16();
if (verify && !(MajorVersion == 1 && MinorVersion == 1 || MajorVersion == 0 && MinorVersion >= 19))
{
throw new BadImageFormatException(string.Format("Unknown MetaData header version: {0}.{1}", MajorVersion, MinorVersion));
}
Reserved1 = reader.ReadUInt32();
StringLength = reader.ReadUInt32();
VersionString = ReadString(reader, StringLength);
StorageHeaderOffset = reader.FileOffset + reader.Position;
Flags = (StorageFlags)reader.ReadByte();
Reserved2 = reader.ReadByte();
Streams = reader.ReadUInt16();
StreamHeaders = new StreamHeader[Streams];
for (var i = 0; i < StreamHeaders.Count; i++)
{
StreamHeaders[i] = new StreamHeader(reader, verify);
}
SetEndoffset(reader);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="reader">PE file reader pointing to the start of this section</param>
/// <param name="runtime">Runtime reader kind</param>
/// <param name="verify">Verify section</param>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
public MetadataHeader(ref DataReader reader, CLRRuntimeReaderKind runtime, bool verify)
{
SetStartOffset(ref reader);
signature = reader.ReadUInt32();
if (verify && signature != 0x424A5342)
{
throw new BadImageFormatException("Invalid metadata header signature");
}
majorVersion = reader.ReadUInt16();
minorVersion = reader.ReadUInt16();
reserved1 = reader.ReadUInt32();
stringLength = reader.ReadUInt32();
versionString = ReadString(ref reader, stringLength, runtime);
offset2ndPart = (FileOffset)reader.CurrentOffset;
flags = (StorageFlags)reader.ReadByte();
reserved2 = reader.ReadByte();
streams = reader.ReadUInt16();
streamHeaders = new StreamHeader[streams];
for (int i = 0; i < streamHeaders.Count; i++)
{
// Mono doesn't verify all of these so we can't either
var sh = new StreamHeader(ref reader, throwOnError: false, verify, runtime, out bool failedVerification);
if (failedVerification || (ulong)sh.Offset + sh.StreamSize > reader.EndOffset)
{
sh = new StreamHeader(0, 0, "<invalid>");
}
streamHeaders[i] = sh;
}
SetEndoffset(ref reader);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="mdReaderFactory">Data reader factory</param>
/// <param name="metadataBaseOffset">Offset of metadata</param>
/// <param name="streamHeader">The stream header</param>
protected DotNetStream(DataReaderFactory mdReaderFactory, uint metadataBaseOffset, StreamHeader streamHeader)
{
this.mdReaderFactory = mdReaderFactory;
mdReaderFactory.DataReaderInvalidated += DataReaderFactory_DataReaderInvalidated;
this.mdReaderFactory = mdReaderFactory;
this.metadataBaseOffset = metadataBaseOffset;
this.streamHeader = streamHeader;
RecreateReader(mdReaderFactory, metadataBaseOffset, streamHeader, notifyThisClass: false);
}
public StorageStreamNode(HexDocument doc, StreamHeader sh, int streamNumber, DotNetStream knownStream, IMetaData md)
: base((ulong)sh.StartOffset, (ulong)sh.EndOffset - 1) {
this.streamNumber = streamNumber;
this.storageStreamType = GetStorageStreamType(knownStream);
this.storageStreamVM = new StorageStreamVM(this, doc, StartOffset, (int)(EndOffset - StartOffset + 1 - 8));
var tblStream = knownStream as TablesStream;
if (tblStream != null)
this.newChild = new TablesStreamNode(doc, tblStream, md);
}
public StorageStreamNode(HexBuffer buffer, StreamHeader sh, int streamNumber, DotNetStream knownStream, IMetaData md)
: base(HexSpan.FromBounds((ulong)sh.StartOffset, (ulong)sh.EndOffset)) {
StreamNumber = streamNumber;
StorageStreamType = GetStorageStreamType(knownStream);
storageStreamVM = new StorageStreamVM(buffer, Span.Start, (int)(Span.Length - 8).ToUInt64());
var tblStream = knownStream as TablesStream;
if (tblStream != null)
newChild = new TablesStreamNode(buffer, tblStream, md);
}
/// <summary>
/// Dispose method
/// </summary>
/// <param name="disposing"><c>true</c> if called by <see cref="Dispose()"/></param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (imageStream != null)
{
imageStream.Dispose();
}
imageStream = null;
streamHeader = null;
}
}
/// <summary>
/// Dispose method
/// </summary>
/// <param name="disposing"><c>true</c> if called by <see cref="Dispose()"/></param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
var mdReaderFactory = this.mdReaderFactory;
if (mdReaderFactory != null)
{
mdReaderFactory.DataReaderInvalidated -= DataReaderFactory_DataReaderInvalidated;
}
streamHeader = null;
this.mdReaderFactory = null;
}
}
/// <inheritdoc/>
public PdbStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader)
{
using (var stream = GetClonedImageStream()) {
Id = stream.ReadBytes(20);
EntryPoint = new MDToken(stream.ReadUInt32());
var tables = stream.ReadUInt64();
ReferencedTypeSystemTables = tables;
var rows = new uint[64];
for (int i = 0; i < rows.Length; i++, tables >>= 1)
{
if (((uint)tables & 1) != 0)
{
rows[i] = stream.ReadUInt32();
}
}
TypeSystemTableRows = rows;
}
}
/// <inheritdoc/>
public PdbStream(DataReaderFactory mdReaderFactory, uint metadataBaseOffset, StreamHeader streamHeader)
: base(mdReaderFactory, metadataBaseOffset, streamHeader)
{
var reader = CreateReader();
Id = reader.ReadBytes(20);
EntryPoint = new MDToken(reader.ReadUInt32());
var tables = reader.ReadUInt64();
ReferencedTypeSystemTables = tables;
var rows = new uint[64];
for (int i = 0; i < rows.Length; i++, tables >>= 1)
{
if (((uint)tables & 1) != 0)
{
rows[i] = reader.ReadUInt32();
}
}
TypeSystemTableRows = rows;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="imageStream">Heap stream</param>
/// <param name="streamHeader">Stream header info</param>
/// <param name="fullStream">Stream for the full PE file</param>
/// <param name="baseOffset">Offset in <paramref name="fullStream"/> where the data starts</param>
public HotStreamCLR40(IImageStream imageStream, StreamHeader streamHeader, IImageStream fullStream, FileOffset baseOffset)
: base(imageStream, streamHeader, fullStream, baseOffset) {
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="imageStream">Stream data</param>
/// <param name="streamHeader">The stream header</param>
public DotNetStream(IImageStream imageStream, StreamHeader streamHeader)
{
this.imageStream = imageStream;
this.streamHeader = streamHeader;
}
/// <inheritdoc/>
public GuidStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader) {
}
/// <inheritdoc/>
protected HeapStream(DataReaderFactory mdReaderFactory, uint metadataBaseOffset, StreamHeader streamHeader)
: base(mdReaderFactory, metadataBaseOffset, streamHeader)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="imageStream">Stream data</param>
/// <param name="streamHeader">The stream header</param>
public DotNetStream(IImageStream imageStream, StreamHeader streamHeader) {
this.imageStream = imageStream;
this.streamHeader = streamHeader;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="imageStream">Heap stream</param>
/// <param name="streamHeader">Stream header info</param>
/// <param name="fullStream">Stream for the full PE file</param>
/// <param name="baseOffset">Offset in <paramref name="fullStream" /> where the data starts</param>
public HotStreamCLR40(IImageStream imageStream, StreamHeader streamHeader, IImageStream fullStream, FileOffset baseOffset)
: base(imageStream, streamHeader, fullStream, baseOffset)
{
}
/// <inheritdoc />
public StringsStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader)
{
}
/// <summary>
/// Dispose method
/// </summary>
/// <param name="disposing"><c>true</c> if called by <see cref="Dispose()"/></param>
protected virtual void Dispose(bool disposing) {
if (disposing) {
var ims = imageStream;
if (ims != null)
ims.Dispose();
imageStream = null;
streamHeader = null;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="reader">PE file reader pointing to the start of this section</param>
/// <param name="verify">Verify section</param>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
public MetaDataHeader(IImageStream reader, bool verify) {
SetStartOffset(reader);
this.signature = reader.ReadUInt32();
if (verify && this.signature != 0x424A5342)
throw new BadImageFormatException("Invalid MetaData header signature");
this.majorVersion = reader.ReadUInt16();
this.minorVersion = reader.ReadUInt16();
if (verify && !((majorVersion == 1 && minorVersion == 1) || (majorVersion == 0 && minorVersion >= 19)))
throw new BadImageFormatException(string.Format("Unknown MetaData header version: {0}.{1}", majorVersion, minorVersion));
this.reserved1 = reader.ReadUInt32();
this.stringLength = reader.ReadUInt32();
this.versionString = ReadString(reader, stringLength);
this.offset2ndPart = (uint)(reader.Position - startOffset);
this.flags = (StorageFlags)reader.ReadByte();
if (verify && this.flags != 0)
throw new BadImageFormatException(string.Format("Storage flags != 0 ({0})", this.flags));
this.reserved2 = reader.ReadByte();
this.streams = reader.ReadUInt16();
this.streamHeaders = new StreamHeader[streams];
for (int i = 0; i < streamHeaders.Count; i++)
streamHeaders[i] = new StreamHeader(reader, verify);
SetEndoffset(reader);
}
/// <summary>
/// Default constructor
/// </summary>
public DotNetStream() {
this.imageStream = MemoryImageStream.CreateEmpty();
this.streamHeader = null;
}
/// <inheritdoc/>
protected HeapStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader) {
}
/// <inheritdoc/>
public BlobStream(DataReaderFactory mdReaderFactory, uint metadataBaseOffset, StreamHeader streamHeader)
: base(mdReaderFactory, metadataBaseOffset, streamHeader)
{
}
/// <inheritdoc/>
public StringsStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader) {
}
/// <inheritdoc/>
public GuidStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader)
{
}
/// <inheritdoc/>
public TablesStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader)
{
}
/// <inheritdoc/>
public BlobStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader) {
}
/// <summary>
/// Creates a <see cref="HotStream" /> instance
/// </summary>
/// <param name="version">Hot heap version</param>
/// <param name="imageStream">Heap stream</param>
/// <param name="streamHeader">Stream header info</param>
/// <param name="fullStream">Stream for the full PE file</param>
/// <param name="baseOffset">Offset in <paramref name="fullStream" /> where the data starts</param>
/// <returns>
/// A <see cref="HotStream" /> instance or <c>null</c> if <paramref name="version" />
/// is invalid
/// </returns>
public static HotStream Create(HotHeapVersion version, IImageStream imageStream, StreamHeader streamHeader, IImageStream fullStream, FileOffset baseOffset)
{
switch (version)
{
case HotHeapVersion.CLR20: return(new HotStreamCLR20(imageStream, streamHeader, fullStream, baseOffset));
case HotHeapVersion.CLR40: return(new HotStreamCLR40(imageStream, streamHeader, fullStream, baseOffset));
default: return(null);
}
}
/// <inheritdoc/>
public TablesStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader) {
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="imageStream">Heap stream</param>
/// <param name="streamHeader">Stream header info</param>
/// <param name="fullStream">Stream for the full PE file</param>
/// <param name="baseOffset">Offset in <paramref name="fullStream"/> where the data starts</param>
protected HotStream(IImageStream imageStream, StreamHeader streamHeader, IImageStream fullStream, FileOffset baseOffset)
: base(imageStream, streamHeader) {
this.fullStream = fullStream;
this.baseOffset = (long)baseOffset;
this.endOffset = (long)baseOffset + imageStream.Length;
}
/// <inheritdoc/>
protected HeapStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader)
{
}
void RecreateReader(DataReaderFactory mdReaderFactory, uint metadataBaseOffset, StreamHeader streamHeader, bool notifyThisClass)
{
if (mdReaderFactory is null || streamHeader is null)
{
dataReader = default;
}
/// <summary>
/// Default constructor
/// </summary>
public DotNetStream()
{
this.imageStream = MemoryImageStream.CreateEmpty();
this.streamHeader = null;
}
/// <summary>
/// Default constructor
/// </summary>
protected DotNetStream()
{
streamHeader = null;
dataReader = default;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="mdReaderFactory">Data reader factory</param>
/// <param name="metadataBaseOffset">Offset of metadata</param>
/// <param name="streamHeader">The stream header</param>
public CustomDotNetStream(DataReaderFactory mdReaderFactory, uint metadataBaseOffset, StreamHeader streamHeader)
: base(mdReaderFactory, metadataBaseOffset, streamHeader)
{
}
void RecreateReader(DataReaderFactory mdReaderFactory, uint metadataBaseOffset, StreamHeader streamHeader, bool notifyThisClass)
{
if (mdReaderFactory == null || streamHeader == null)
{
dataReader = default;
}
else
{
dataReader = mdReaderFactory.CreateReader(metadataBaseOffset + streamHeader.Offset, streamHeader.StreamSize);
}
if (notifyThisClass)
{
OnReaderRecreated();
}
}
/// <inheritdoc/>
public BlobStream(IImageStream imageStream, StreamHeader streamHeader)
: base(imageStream, streamHeader)
{
}
