private ImmutableArray<SectionHeader> ReadSectionHeaders(ref PEBinaryReader reader)
{
int numberOfSections = _coffHeader.NumberOfSections;
if (numberOfSections < 0)
{
throw new BadImageFormatException(SR.InvalidNumberOfSections);
}
var builder = ImmutableArray.CreateBuilder<SectionHeader>(numberOfSections);
for (int i = 0; i < numberOfSections; i++)
{
builder.Add(new SectionHeader(ref reader));
}
return builder.ToImmutable();
}
/// <summary>
/// Reads PE headers from the current location in the stream.
/// </summary>
/// <param name="peStream">Stream containing PE image of the given size starting at its current position.</param>
/// <param name="size">Size of the PE image.</param>
/// <param name="isLoadedImage">True if the PE image has been loaded into memory by the OS loader.</param>
/// <exception cref="BadImageFormatException">The data read from stream have invalid format.</exception>
/// <exception cref="IOException">Error reading from the stream.</exception>
/// <exception cref="ArgumentException">The stream doesn't support seek operations.</exception>
/// <exception cref="ArgumentNullException"><paramref name="peStream"/> is null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Size is negative or extends past the end of the stream.</exception>
public PEHeaders(Stream peStream, int size, bool isLoadedImage)
{
if (peStream == null)
{
throw new ArgumentNullException(nameof(peStream));
}
if (!peStream.CanRead || !peStream.CanSeek)
{
throw new ArgumentException(SR.StreamMustSupportReadAndSeek, nameof(peStream));
}
_isLoadedImage = isLoadedImage;
int actualSize = StreamExtensions.GetAndValidateSize(peStream, size, nameof(peStream));
var reader = new PEBinaryReader(peStream, actualSize);
bool isCoffOnly;
SkipDosHeader(ref reader, out isCoffOnly);
_coffHeaderStartOffset = reader.CurrentOffset;
_coffHeader = new CoffHeader(ref reader);
if (!isCoffOnly)
{
_peHeaderStartOffset = reader.CurrentOffset;
_peHeader = new PEHeader(ref reader);
}
_sectionHeaders = this.ReadSectionHeaders(ref reader);
if (!isCoffOnly)
{
int offset;
if (TryCalculateCorHeaderOffset(actualSize, out offset))
{
_corHeaderStartOffset = offset;
reader.Seek(offset);
_corHeader = new CorHeader(ref reader);
}
}
CalculateMetadataLocation(actualSize, out _metadataStartOffset, out _metadataSize);
}
private void SkipDosHeader(ref PEBinaryReader reader, out bool isCOFFOnly)
{
// Look for DOS Signature "MZ"
ushort dosSig = reader.ReadUInt16();
if (dosSig != DosSignature)
{
// If image doesn't start with DOS signature, let's assume it is a
// COFF (Common Object File Format), aka .OBJ file.
// See CLiteWeightStgdbRW::FindObjMetaData in ndp\clr\src\MD\enc\peparse.cpp
if (dosSig != 0 || reader.ReadUInt16() != 0xffff)
{
isCOFFOnly = true;
reader.Seek(0);
}
else
{
// Might need to handle other formats. Anonymous or LTCG objects, for example.
throw new BadImageFormatException(SR.UnknownFileFormat);
}
}
else
{
isCOFFOnly = false;
}
if (!isCOFFOnly)
{
// Skip the DOS Header
reader.Seek(PESignatureOffsetLocation);
int ntHeaderOffset = reader.ReadInt32();
reader.Seek(ntHeaderOffset);
// Look for PESignature "PE\0\0"
uint ntSignature = reader.ReadUInt32();
if (ntSignature != PESignature)
{
throw new BadImageFormatException(SR.InvalidPESignature);
}
}
}
16 * sizeof(long); // directory entries
internal PEHeader(ref PEBinaryReader reader)
{
PEMagic magic = (PEMagic)reader.ReadUInt16();
if (magic != PEMagic.PE32 && magic != PEMagic.PE32Plus)
{
throw new BadImageFormatException(SR.UnknownPEMagicValue);
}
Magic = magic;
MajorLinkerVersion = reader.ReadByte();
MinorLinkerVersion = reader.ReadByte();
SizeOfCode = reader.ReadInt32();
SizeOfInitializedData = reader.ReadInt32();
SizeOfUninitializedData = reader.ReadInt32();
AddressOfEntryPoint = reader.ReadInt32();
BaseOfCode = reader.ReadInt32();
if (magic == PEMagic.PE32Plus)
{
BaseOfData = 0; // not present
}
else
{
Debug.Assert(magic == PEMagic.PE32);
BaseOfData = reader.ReadInt32();
}
if (magic == PEMagic.PE32Plus)
{
ImageBase = reader.ReadUInt64();
}
else
{
ImageBase = reader.ReadUInt32();
}
// NT additional fields:
SectionAlignment = reader.ReadInt32();
FileAlignment = reader.ReadInt32();
MajorOperatingSystemVersion = reader.ReadUInt16();
MinorOperatingSystemVersion = reader.ReadUInt16();
MajorImageVersion = reader.ReadUInt16();
MinorImageVersion = reader.ReadUInt16();
MajorSubsystemVersion = reader.ReadUInt16();
MinorSubsystemVersion = reader.ReadUInt16();
// Win32VersionValue (reserved, should be 0)
reader.ReadUInt32();
SizeOfImage = reader.ReadInt32();
SizeOfHeaders = reader.ReadInt32();
CheckSum = reader.ReadUInt32();
Subsystem = (Subsystem)reader.ReadUInt16();
DllCharacteristics = (DllCharacteristics)reader.ReadUInt16();
if (magic == PEMagic.PE32Plus)
{
SizeOfStackReserve = reader.ReadUInt64();
SizeOfStackCommit = reader.ReadUInt64();
SizeOfHeapReserve = reader.ReadUInt64();
SizeOfHeapCommit = reader.ReadUInt64();
}
else
{
SizeOfStackReserve = reader.ReadUInt32();
SizeOfStackCommit = reader.ReadUInt32();
SizeOfHeapReserve = reader.ReadUInt32();
SizeOfHeapCommit = reader.ReadUInt32();
}
// loader flags
reader.ReadUInt32();
NumberOfRvaAndSizes = reader.ReadInt32();
// directory entries:
ExportTableDirectory = new DirectoryEntry(ref reader);
ImportTableDirectory = new DirectoryEntry(ref reader);
ResourceTableDirectory = new DirectoryEntry(ref reader);
ExceptionTableDirectory = new DirectoryEntry(ref reader);
CertificateTableDirectory = new DirectoryEntry(ref reader);
BaseRelocationTableDirectory = new DirectoryEntry(ref reader);
DebugTableDirectory = new DirectoryEntry(ref reader);
CopyrightTableDirectory = new DirectoryEntry(ref reader);
GlobalPointerTableDirectory = new DirectoryEntry(ref reader);
ThreadLocalStorageTableDirectory = new DirectoryEntry(ref reader);
LoadConfigTableDirectory = new DirectoryEntry(ref reader);
BoundImportTableDirectory = new DirectoryEntry(ref reader);
ImportAddressTableDirectory = new DirectoryEntry(ref reader);
DelayImportTableDirectory = new DirectoryEntry(ref reader);
CorHeaderTableDirectory = new DirectoryEntry(ref reader);
// ReservedDirectory (should be 0, 0)
new DirectoryEntry(ref reader);
}
