// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

// See the LICENSE file in the project root for more information.

// --------------------------------------------------------------------------------

// PEDecoder.cpp

//

// --------------------------------------------------------------------------------

#include "stdafx.h"

#include "ex.h"

#include "pedecoder.h"

#include "mdcommon.h"

#include "nibblemapmacros.h"

CHECK PEDecoder::CheckFormat() const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_CHECK_END;

CHECK(HasContents());

if (HasNTHeaders())

{

CHECK(CheckNTHeaders());

if (HasCorHeader())

{

CHECK(CheckCorHeader());

if (IsILOnly())

CHECK(CheckILOnly());

if (HasNativeHeader())

CHECK(CheckNativeHeader());

CHECK(CheckWillCreateGuardPage());

}

}

CHECK_OK;

}

CHECK PEDecoder::CheckNTFormat() const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

PRECONDITION(HasContents());

}

CONTRACT_CHECK_END;

CHECK(CheckFormat());

CHECK(HasNTHeaders());

CHECK_OK;

}

CHECK PEDecoder::CheckCORFormat() const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

PRECONDITION(HasContents());

}

CONTRACT_CHECK_END;

CHECK(CheckFormat());

CHECK(HasNTHeaders());

CHECK(HasCorHeader());

CHECK_OK;

}

CHECK PEDecoder::CheckILFormat() const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

PRECONDITION(HasContents());

}

CONTRACT_CHECK_END;

CHECK(CheckFormat());

CHECK(HasNTHeaders());

CHECK(HasCorHeader());

CHECK(!HasNativeHeader());

CHECK_OK;

}

CHECK PEDecoder::CheckILOnlyFormat() const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

PRECONDITION(HasContents());

}

CONTRACT_CHECK_END;

CHECK(CheckFormat());

CHECK(HasNTHeaders());

CHECK(HasCorHeader());

CHECK(IsILOnly());

CHECK(!HasNativeHeader());

CHECK_OK;

}

CHECK PEDecoder::CheckNativeFormat() const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

PRECONDITION(HasContents());

}

CONTRACT_CHECK_END;

#ifdef FEATURE_PREJIT

CHECK(CheckFormat());

CHECK(HasNTHeaders());

CHECK(HasCorHeader());

CHECK(!IsILOnly());

CHECK(HasNativeHeader());

#else // FEATURE_PREJIT

CHECK(false);

#endif // FEATURE_PREJIT

CHECK_OK;

}

BOOL PEDecoder::HasNTHeaders() const

{

CONTRACT(BOOL)

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

SUPPORTS_DAC;

PRECONDITION(HasContents());

}

CONTRACT_END;

// Check for a valid DOS header

if (m_size < sizeof(IMAGE_DOS_HEADER))

RETURN FALSE;

IMAGE_DOS_HEADER* pDOS = PTR_IMAGE_DOS_HEADER(m_base);

{

if (pDOS->e_magic != VAL16(IMAGE_DOS_SIGNATURE)

|| (DWORD) pDOS->e_lfanew == VAL32(0))

{

RETURN FALSE;

}

// Check for integer overflow

S_SIZE_T cbNTHeaderEnd(S_SIZE_T(static_cast<SIZE_T>(VAL32(pDOS->e_lfanew))) +

S_SIZE_T(sizeof(IMAGE_NT_HEADERS)));

if (cbNTHeaderEnd.IsOverflow())

{

RETURN FALSE;

}

// Now check for a valid NT header

if (m_size < cbNTHeaderEnd.Value())

{

RETURN FALSE;

}

}

IMAGE_NT_HEADERS *pNT = PTR_IMAGE_NT_HEADERS(m_base + VAL32(pDOS->e_lfanew));

if (pNT->Signature != VAL32(IMAGE_NT_SIGNATURE))

RETURN FALSE;

if (pNT->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR32_MAGIC))

{

if (pNT->FileHeader.SizeOfOptionalHeader != VAL16(sizeof(IMAGE_OPTIONAL_HEADER32)))

RETURN FALSE;

}

else if (pNT->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR64_MAGIC))

{

// on 64 bit we can promote this

if (pNT->FileHeader.SizeOfOptionalHeader != VAL16(sizeof(IMAGE_OPTIONAL_HEADER64)))

RETURN FALSE;

// Check for integer overflow

S_SIZE_T cbNTHeaderEnd(S_SIZE_T(static_cast<SIZE_T>(VAL32(pDOS->e_lfanew))) +

S_SIZE_T(sizeof(IMAGE_NT_HEADERS64)));

if (cbNTHeaderEnd.IsOverflow())

{

RETURN FALSE;

}

// Now check for a valid NT header

if (m_size < cbNTHeaderEnd.Value())

{

RETURN FALSE;

}

}

else

RETURN FALSE;

// Go ahead and cache NT header since we already found it.

const_cast<PEDecoder *>(this)->m_pNTHeaders = dac_cast<PTR_IMAGE_NT_HEADERS>(pNT);

RETURN TRUE;

}

CHECK PEDecoder::CheckNTHeaders() const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

SUPPORTS_DAC;

PRECONDITION(HasContents());

}

CONTRACT_CHECK_END;

// Only check once per file

if (m_flags & FLAG_NT_CHECKED)

CHECK_OK;

CHECK(HasNTHeaders());

IMAGE_NT_HEADERS *pNT = FindNTHeaders();

CHECK((pNT->FileHeader.Characteristics & VAL16(IMAGE_FILE_SYSTEM)) == 0);

CHECK(CheckAlignment(VAL32(pNT->OptionalHeader.FileAlignment)));

CHECK(CheckAlignment(VAL32(pNT->OptionalHeader.SectionAlignment)));

CHECK(CheckAligned((UINT)VAL32(pNT->OptionalHeader.FileAlignment), 512));

CHECK(CheckAligned((UINT)VAL32(pNT->OptionalHeader.SectionAlignment), VAL32(pNT->OptionalHeader.FileAlignment)));

CHECK(CheckAligned((UINT)VAL32(pNT->OptionalHeader.SizeOfImage), VAL32(pNT->OptionalHeader.SectionAlignment)));

CHECK(CheckAligned((UINT)VAL32(pNT->OptionalHeader.SizeOfHeaders), VAL32(pNT->OptionalHeader.FileAlignment)));

// Data directories will be validated later on.

PTR_IMAGE_DATA_DIRECTORY pDataDirectories = NULL;

if (Has32BitNTHeaders())

{

IMAGE_NT_HEADERS32* pNT32=GetNTHeaders32();

CHECK(CheckAligned(VAL32(pNT32->OptionalHeader.ImageBase), 0x10000));

CHECK((VAL32(pNT32->OptionalHeader.SizeOfStackCommit) <= VAL32(pNT32->OptionalHeader.SizeOfStackReserve)));

CHECK((VAL32(pNT32->OptionalHeader.SizeOfHeapCommit) <= VAL32(pNT32->OptionalHeader.SizeOfHeapReserve)));

pDataDirectories = dac_cast<PTR_IMAGE_DATA_DIRECTORY>(

dac_cast<TADDR>(pNT32) + offsetof(IMAGE_NT_HEADERS32, OptionalHeader.DataDirectory));

}

else

{

IMAGE_NT_HEADERS64* pNT64=GetNTHeaders64();

CHECK(CheckAligned(VAL64(pNT64->OptionalHeader.ImageBase), 0x10000));

CHECK((VAL64(pNT64->OptionalHeader.SizeOfStackCommit) <= VAL64(pNT64->OptionalHeader.SizeOfStackReserve)));

CHECK((VAL64(pNT64->OptionalHeader.SizeOfHeapCommit) <= VAL64(pNT64->OptionalHeader.SizeOfHeapReserve)));

pDataDirectories = dac_cast<PTR_IMAGE_DATA_DIRECTORY>(

dac_cast<TADDR>(pNT64) + offsetof(IMAGE_NT_HEADERS64, OptionalHeader.DataDirectory));

}

// @todo: this is a bit awkward here, it would be better to make this assertion on

// PEDecoder instantiation. However, we don't necessarily have the NT headers there (in fact

// they might not exist.)

if (IsMapped())

{

// Ideally we would require the layout address to honor the section alignment constraints.

// However, we do have 8K aligned IL only images which we load on 32 bit platforms. In this

// case, we can only guarantee OS page alignment (which after all, is good enough.)

CHECK(CheckAligned(m_base, GetOsPageSize()));

}

// @todo: check NumberOfSections for overflow of SizeOfHeaders

UINT32 currentAddress = 0;

UINT32 currentOffset = 0;

CHECK(CheckSection(currentAddress, 0, VAL32(pNT->OptionalHeader.SizeOfHeaders),

currentOffset, 0, VAL32(pNT->OptionalHeader.SizeOfHeaders)));

currentAddress=currentOffset=VAL32(pNT->OptionalHeader.SizeOfHeaders);

PTR_IMAGE_SECTION_HEADER section = FindFirstSection(pNT);

PTR_IMAGE_SECTION_HEADER sectionEnd = section + VAL16(pNT->FileHeader.NumberOfSections);

CHECK(sectionEnd >= section);

while (section < sectionEnd)

{

//

// NOTE: the if condition is becuase of a design issue in the CLR and OS loader's remapping

// of PE32 headers to PE32+. Because IMAGE_NT_HEADERS64 is bigger than IMAGE_NT_HEADERS32,

// the remapping will expand this part of the header and push out the following

// IMAGE_SECTION_HEADER entries. When IMAGE_DOS_HEADER::e_lfanew is large enough (size is

// proportional to the number of tools used to produce the inputs to the C++ linker, and

// has become larger when producing some WinMD files) this can push the last section header

// beyond the boundary set by IMAGE_NT_HEADERS::OptionalHeader.SizeOfHeaders (e.g., this

// was recently seen where the unaligned size of the headers was 0x1f8 and SizeOfHeaders was

// 0x200, and the header remapping resulted in new headers size of 0x208). To compensate

// for this issue (it would be quite difficult to fix in the remapping code; see Dev11 430008)

// we assume that when the image is mapped that the needed validation has already been done.

//

if (!IsMapped())

{

CHECK(CheckBounds(dac_cast<PTR_CVOID>(pNT),VAL32(pNT->OptionalHeader.SizeOfHeaders),

section,sizeof(IMAGE_SECTION_HEADER)));

}

// Check flags

// Only allow a small list of characteristics

CHECK(!(section->Characteristics &

~(VAL32((IMAGE_SCN_CNT_CODE |

IMAGE_SCN_CNT_INITIALIZED_DATA |

IMAGE_SCN_CNT_UNINITIALIZED_DATA|

IMAGE_SCN_MEM_DISCARDABLE |

IMAGE_SCN_MEM_NOT_CACHED |

IMAGE_SCN_MEM_NOT_PAGED |

IMAGE_SCN_MEM_EXECUTE |

IMAGE_SCN_MEM_READ |

IMAGE_SCN_MEM_WRITE |

// allow shared sections for all images for now.

// we'll constrain this in CheckILOnly

IMAGE_SCN_MEM_SHARED)))));

// we should not allow writable code sections, check if both flags are set

CHECK((section->Characteristics & VAL32((IMAGE_SCN_CNT_CODE|IMAGE_SCN_MEM_WRITE))) !=

VAL32((IMAGE_SCN_CNT_CODE|IMAGE_SCN_MEM_WRITE)));

CHECK(CheckSection(currentAddress, VAL32(section->VirtualAddress), VAL32(section->Misc.VirtualSize),

currentOffset, VAL32(section->PointerToRawData), VAL32(section->SizeOfRawData)));

currentAddress = VAL32(section->VirtualAddress)

+ AlignUp((UINT)VAL32(section->Misc.VirtualSize), (UINT)VAL32(pNT->OptionalHeader.SectionAlignment));

currentOffset = VAL32(section->PointerToRawData) + VAL32(section->SizeOfRawData);

section++;

}

// Now check that the COR data directory is either NULL, or exists entirely in one section.

{

PTR_IMAGE_DATA_DIRECTORY pCORDataDir = pDataDirectories + IMAGE_DIRECTORY_ENTRY_COMHEADER;

CHECK(CheckRva(VAL32(pCORDataDir->VirtualAddress), VAL32(pCORDataDir->Size), 0, NULL_OK));

}

// @todo: verify directory entries

const_cast<PEDecoder *>(this)->m_flags |= FLAG_NT_CHECKED;

CHECK_OK;

}

CHECK PEDecoder::CheckSection(COUNT_T previousAddressEnd, COUNT_T addressStart, COUNT_T addressSize,

COUNT_T previousOffsetEnd, COUNT_T offsetStart, COUNT_T offsetSize) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(HasNTHeaders());

NOTHROW;

GC_NOTRIGGER;

SUPPORTS_DAC;

}

CONTRACT_CHECK_END;

// Fetch the NT header

IMAGE_NT_HEADERS *pNT = FindNTHeaders();

// OS will zero pad a mapped file up to file alignment size - some images rely on this

// COUNT_T alignedSize = AlignUp(m_size, VAL32(pNT->OptionalHeader.FileAlignment));

COUNT_T alignedSize = IsMapped() ? AlignUp(m_size, VAL32(pNT->OptionalHeader.FileAlignment)) : m_size;

// Check to make sure that our memory is big enough to cover the stated range.

// Note that this check is only required if we have a non-flat image.

if (IsMapped())

CHECK(alignedSize >= VAL32(pNT->OptionalHeader.SizeOfImage));

// Check expected alignments

CHECK(CheckAligned(addressStart, VAL32(pNT->OptionalHeader.SectionAlignment)));

CHECK(CheckAligned(offsetStart, VAL32(pNT->OptionalHeader.FileAlignment)));

CHECK(CheckAligned(offsetSize, VAL32(pNT->OptionalHeader.FileAlignment)));

// addressSize is typically not aligned, so we align it for purposes of checks.

COUNT_T alignedAddressSize = AlignUp(addressSize, VAL32(pNT->OptionalHeader.SectionAlignment));

CHECK(addressSize <= alignedAddressSize);

// Check overflow

CHECK(CheckOverflow(addressStart, alignedAddressSize));

CHECK(CheckOverflow(offsetStart, offsetSize));

// Make sure we don't overlap the previous section

CHECK(addressStart >= previousAddressEnd

&& (offsetSize == 0

|| offsetStart >= previousOffsetEnd));

// Make sure we don't overrun the end of the mapped image

CHECK(addressStart + alignedAddressSize <= VAL32(pNT->OptionalHeader.SizeOfImage));

// Make sure we don't overrun the end of the file (only relevant if we're not mapped, otherwise

// we don't know the file size, as it's not declared in the headers.)

if (!IsMapped())

CHECK(offsetStart + offsetSize <= alignedSize);

// Make sure the data doesn't overrun the virtual address space

CHECK(offsetSize <= alignedAddressSize);

CHECK_OK;

}

BOOL PEDecoder::HasWriteableSections() const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

PRECONDITION(CheckFormat());

NOTHROW;

GC_NOTRIGGER;

SUPPORTS_DAC;

}

CONTRACT_CHECK_END;

PTR_IMAGE_SECTION_HEADER pSection = FindFirstSection();

_ASSERTE(pSection != NULL);

PTR_IMAGE_SECTION_HEADER pSectionEnd = pSection + VAL16(FindNTHeaders()->FileHeader.NumberOfSections);

while (pSection < pSectionEnd)

{

if ((pSection->Characteristics & VAL32(IMAGE_SCN_MEM_WRITE)) != 0)

{

return TRUE;

}

pSection++;

}

return FALSE;

}

CHECK PEDecoder::CheckDirectoryEntry(int entry, int forbiddenFlags, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

PRECONDITION(entry < IMAGE_NUMBEROF_DIRECTORY_ENTRIES);

PRECONDITION(HasDirectoryEntry(entry));

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_CHECK_END;

CHECK(CheckDirectory(GetDirectoryEntry(entry), forbiddenFlags, ok));

CHECK_OK;

}

CHECK PEDecoder::CheckDirectory(IMAGE_DATA_DIRECTORY *pDir, int forbiddenFlags, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

PRECONDITION(CheckPointer(pDir));

NOTHROW;

GC_NOTRIGGER;

SUPPORTS_DAC;

}

CONTRACT_CHECK_END;

CHECK(CheckRva(VAL32(pDir->VirtualAddress), VAL32(pDir->Size), forbiddenFlags, ok));

CHECK_OK;

}

CHECK PEDecoder::CheckRva(RVA rva, COUNT_T size, int forbiddenFlags, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

SUPPORTS_DAC;

}

CONTRACT_CHECK_END;

if (rva == 0)

{

CHECK_MSG(ok == NULL_OK, "Zero RVA illegal");

CHECK(size == 0);

}

else

{

IMAGE_SECTION_HEADER *section = RvaToSection(rva);

CHECK(section != NULL);

CHECK(CheckBounds(VAL32(section->VirtualAddress),

// AlignUp((UINT)VAL32(section->Misc.VirtualSize), (UINT)VAL32(FindNTHeaders()->OptionalHeader.SectionAlignment)),

(UINT)VAL32(section->Misc.VirtualSize),

rva, size));

if(!IsMapped())

{

CHECK(CheckBounds(VAL32(section->VirtualAddress), VAL32(section->SizeOfRawData), rva, size));

}

if (forbiddenFlags!=0)

CHECK((section->Characteristics & VAL32(forbiddenFlags))==0);

}

CHECK_OK;

}

CHECK PEDecoder::CheckRva(RVA rva, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

SUPPORTS_DAC;

}

CONTRACT_CHECK_END;

if (rva == 0)

CHECK_MSG(ok == NULL_OK, "Zero RVA illegal");

else

CHECK(RvaToSection(rva) != NULL);

CHECK_OK;

}

CHECK PEDecoder::CheckOffset(COUNT_T fileOffset, COUNT_T size, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_CHECK_END;

if (fileOffset == 0)

{

CHECK_MSG(ok == NULL_OK, "zero fileOffset illegal");

CHECK(size == 0);

}

else

{

IMAGE_SECTION_HEADER *section = OffsetToSection(fileOffset);

CHECK(section != NULL);

CHECK(CheckBounds(section->PointerToRawData, section->SizeOfRawData,

fileOffset, size));

}

CHECK_OK;

}

CHECK PEDecoder::CheckOffset(COUNT_T fileOffset, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_CHECK_END;

if (fileOffset == NULL)

CHECK_MSG(ok == NULL_OK, "Null pointer illegal");

else

{

CHECK(OffsetToSection(fileOffset) != NULL);

}

CHECK_OK;

}

CHECK PEDecoder::CheckData(const void *data, COUNT_T size, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_CHECK_END;

if (data == NULL)

{

CHECK_MSG(ok == NULL_OK, "NULL pointer illegal");

CHECK(size == 0);

}

else

{

CHECK(CheckUnderflow(data, m_base));

CHECK((UINT_PTR) (((BYTE *) data) - ((BYTE *) m_base)) <= COUNT_T_MAX);

if (IsMapped())

CHECK(CheckRva((COUNT_T) ((BYTE *) data - (BYTE *) m_base), size));

else

CHECK(CheckOffset((COUNT_T) ((BYTE *) data - (BYTE *) m_base), size));

}

CHECK_OK;

}

CHECK PEDecoder::CheckData(const void *data, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_CHECK_END;

if (data == NULL)

CHECK_MSG(ok == NULL_OK, "Null pointer illegal");

else

{

CHECK(CheckUnderflow(data, m_base));

CHECK((UINT_PTR) (((BYTE *) data) - ((BYTE *) m_base)) <= COUNT_T_MAX);

if (IsMapped())

CHECK(CheckRva((COUNT_T) ((BYTE *) data - (BYTE *) m_base)));

else

CHECK(CheckOffset((COUNT_T) ((BYTE *) data - (BYTE *) m_base)));

}

CHECK_OK;

}

CHECK PEDecoder::CheckInternalAddress(SIZE_T address, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_CHECK_END;

if (address == 0)

CHECK_MSG(ok == NULL_OK, "Zero RVA illegal");

else

CHECK(RvaToSection(InternalAddressToRva(address)) != NULL);

CHECK_OK;

}

CHECK PEDecoder::CheckInternalAddress(SIZE_T address, COUNT_T size, IsNullOK ok) const

{

CONTRACT_CHECK

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_CHECK_END;

if (address == 0)

{

CHECK_MSG(ok == NULL_OK, "Zero RVA illegal");

CHECK(size == 0);

}

else

{

CHECK(CheckRva(InternalAddressToRva(address), size));

}

CHECK_OK;

}

RVA PEDecoder::InternalAddressToRva(SIZE_T address) const

{

CONTRACT(RVA)

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

NOTHROW;

GC_NOTRIGGER;

POSTCONDITION(CheckRva(RETVAL));

}

CONTRACT_END;

if (m_flags & FLAG_RELOCATED)

{

// Address has been fixed up

RETURN (RVA) ((BYTE *) address - (BYTE *) m_base);

}

else

{

// Address has not been fixed up

RETURN (RVA) (address - (SIZE_T) GetPreferredBase());

}

}

// Returns a pointer to the named section or NULL if not found.

// The name should include the starting "." as well.

IMAGE_SECTION_HEADER *PEDecoder::FindSection(LPCSTR sectionName) const

{

CONTRACT(IMAGE_SECTION_HEADER *)

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

PRECONDITION(sectionName != NULL);

NOTHROW;

GC_NOTRIGGER;

CANNOT_TAKE_LOCK;

POSTCONDITION(CheckPointer(RETVAL, NULL_OK));

}

CONTRACT_END;

// Ensure that the section name length is valid

SIZE_T iSectionNameLength = strlen(sectionName);

if ((iSectionNameLength < 1) || (iSectionNameLength > IMAGE_SIZEOF_SHORT_NAME))

{

_ASSERTE(!"Invalid section name!");

RETURN NULL;

}

// Get the start and ends of the sections

PTR_IMAGE_SECTION_HEADER pSection = FindFirstSection(FindNTHeaders());

_ASSERTE(pSection != NULL);

PTR_IMAGE_SECTION_HEADER pSectionEnd = pSection + VAL16(FindNTHeaders()->FileHeader.NumberOfSections);

_ASSERTE(pSectionEnd != NULL);

BOOL fFoundSection = FALSE;

// Loop thru the sections and see if we got the section we are interested in

while (pSection < pSectionEnd)

{

// Is this the section we are looking for?

if (strncmp(sectionName, (char*)pSection->Name, iSectionNameLength) == 0)

{

// We found our section - break out of the loop

fFoundSection = TRUE;

break;

}

// Move to the next section

pSection++;

}

if (TRUE == fFoundSection)

RETURN pSection;

else

RETURN NULL;

}

IMAGE_SECTION_HEADER *PEDecoder::RvaToSection(RVA rva) const

{

CONTRACT(IMAGE_SECTION_HEADER *)

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

CANNOT_TAKE_LOCK;

POSTCONDITION(CheckPointer(RETVAL, NULL_OK));

SUPPORTS_DAC;

}

CONTRACT_END;

PTR_IMAGE_SECTION_HEADER section = dac_cast<PTR_IMAGE_SECTION_HEADER>(FindFirstSection(FindNTHeaders()));

PTR_IMAGE_SECTION_HEADER sectionEnd = section + VAL16(FindNTHeaders()->FileHeader.NumberOfSections);

while (section < sectionEnd)

{

if (rva < (VAL32(section->VirtualAddress)

+ AlignUp((UINT)VAL32(section->Misc.VirtualSize), (UINT)VAL32(FindNTHeaders()->OptionalHeader.SectionAlignment))))

{

if (rva < VAL32(section->VirtualAddress))

RETURN NULL;

else

{

RETURN section;

}

}

section++;

}

RETURN NULL;

}

IMAGE_SECTION_HEADER *PEDecoder::OffsetToSection(COUNT_T fileOffset) const

{

CONTRACT(IMAGE_SECTION_HEADER *)

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

NOTHROW;

GC_NOTRIGGER;

POSTCONDITION(CheckPointer(RETVAL, NULL_OK));

SUPPORTS_DAC;

}

CONTRACT_END;

PTR_IMAGE_SECTION_HEADER section = dac_cast<PTR_IMAGE_SECTION_HEADER>(FindFirstSection(FindNTHeaders()));

PTR_IMAGE_SECTION_HEADER sectionEnd = section + VAL16(FindNTHeaders()->FileHeader.NumberOfSections);

while (section < sectionEnd)

{

if (fileOffset < section->PointerToRawData + section->SizeOfRawData)

{

if (fileOffset < section->PointerToRawData)

RETURN NULL;

else

RETURN section;

}

section++;

}

RETURN NULL;

}

TADDR PEDecoder::GetRvaData(RVA rva, IsNullOK ok /*= NULL_NOT_OK*/) const

{

CONTRACT(TADDR)

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

PRECONDITION(CheckRva(rva, NULL_OK));

NOTHROW;

GC_NOTRIGGER;

CANNOT_TAKE_LOCK;

SUPPORTS_DAC;

}

CONTRACT_END;

if ((rva == 0)&&(ok == NULL_NOT_OK))

RETURN NULL;

RVA offset;

if (IsMapped())

offset = rva;

else

{

// !!! check for case where rva is in padded portion of segment

offset = RvaToOffset(rva);

}

RETURN( m_base + offset );

}

RVA PEDecoder::GetDataRva(const TADDR data) const

{

CONTRACT(RVA)

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

PRECONDITION(CheckData((void *)data, NULL_OK));

NOTHROW;

GC_NOTRIGGER;

SUPPORTS_DAC;

}

CONTRACT_END;

if (data == NULL)

RETURN 0;

COUNT_T offset = (COUNT_T) (data - m_base);

if (IsMapped())

RETURN offset;

else

RETURN OffsetToRva(offset);

}

BOOL PEDecoder::PointerInPE(PTR_CVOID data) const

{

CONTRACTL

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

FORBID_FAULT;

SUPPORTS_DAC;

}

CONTRACTL_END;

TADDR taddrData = dac_cast<TADDR>(data);

TADDR taddrBase = dac_cast<TADDR>(m_base);

if (this->IsMapped())

{

return taddrBase <= taddrData && taddrData < taddrBase + GetVirtualSize();

}

else

{

return taddrBase <= taddrData && taddrData < taddrBase + GetSize();

}

}

TADDR PEDecoder::GetOffsetData(COUNT_T fileOffset, IsNullOK ok /*= NULL_NOT_OK*/) const

{

CONTRACT(TADDR)

{

INSTANCE_CHECK;

PRECONDITION(CheckNTHeaders());

PRECONDITION(CheckOffset(fileOffset, NULL_OK));

NOTHROW;

GC_NOTRIGGER;

}

CONTRACT_END;

if ((fileOffset == 0)&&(ok == NULL_NOT_OK))

RETURN NULL;

RETURN GetRvaData(OffsetToRva(fileOffset));

}

//-------------------------------------------------------------------------------

// Lifted from "..\md\inc\mdfileformat.h"

// (cannot #include it here because it references lot of other stuff)

#define STORAGE_MAGIC_SIG 0x424A5342 // BSJB

struct STORAGESIGNATURE

{

ULONG lSignature; // "Magic" signature.

USHORT iMajorVer; // Major file version.

USHORT iMinorVer; // Minor file version.

ULONG iExtraData; // Offset to next structure of information

ULONG iVersionString; // Length of version string

};

typedef STORAGESIGNATURE UNALIGNED * PSTORAGESIGNATURE;

typedef DPTR(STORAGESIGNATURE UNALIGNED) PTR_STORAGESIGNATURE;

struct STORAGEHEADER

{

BYTE fFlags; // STGHDR_xxx flags.

BYTE pad;

USHORT iStreams; // How many streams are there.

};

typedef STORAGEHEADER UNALIGNED * PSTORAGEHEADER;

typedef DPTR(STORAGEHEADER UNALIGNED) PTR_STORAGEHEADER;

struct STORAGESTREAM

{

ULONG iOffset; // Offset in file for this stream.

ULONG iSize; // Size of the file.

char rcName[32]; // Start of name, null terminated.

};

typedef STORAGESTREAM UNALIGNED * PSTORAGESTREAM;

typedef DPTR(STORAGESTREAM UNALIGNED) PTR_STORAGESTREAM;

// if the stream's name is shorter than 32 bytes (incl.zero terminator),

// the size of storage stream header is less than sizeof(STORAGESTREAM)

// and is padded to 4-byte alignment

inline PTR_STORAGESTREAM NextStorageStream(PTR_STORAGESTREAM pSS)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

CANNOT_TAKE_LOCK;

}

CONTRACTL_END;

SUPPORTS_DAC;

TADDR pc = dac_cast<TADDR>(pSS);

pc += (sizeof(STORAGESTREAM) - 32 /*sizeof(STORAGESTREAM::rcName)*/ + strlen(pSS->rcName)+1+3)&~3;