void ReadLines(PdbReader reader, IImageStream stream) {
var docs = new Dictionary<long, DbiDocument>();
stream.Position = 0;
while (stream.Position < stream.Length) {
var sig = (ModuleStreamType)stream.ReadUInt32();
var size = stream.ReadUInt32();
var begin = stream.Position;
var end = (begin + size + 3) & ~3;
if (sig == ModuleStreamType.FileInfo)
ReadFiles(reader, docs, stream, end);
stream.Position = end;
}
var sortedFuncs = new DbiFunction[Functions.Count];
Functions.CopyTo(sortedFuncs, 0);
Array.Sort(sortedFuncs, (a, b) => a.Address.CompareTo(b.Address));
stream.Position = 0;
while (stream.Position < stream.Length) {
var sig = (ModuleStreamType)stream.ReadUInt32();
var size = stream.ReadUInt32();
var begin = stream.Position;
var end = begin + size;
if (sig == ModuleStreamType.Lines)
ReadLines(sortedFuncs, docs, stream, end);
stream.Position = end;
}
}
void Populate(IImageStream reader) {
var chars = new char[0x200];
reader.Position = 1;
while (reader.Position < reader.Length) {
uint offset = (uint)reader.Position;
uint len;
if (!reader.ReadCompressedUInt32(out len)) {
if (offset == reader.Position)
reader.Position++;
continue;
}
if (len == 0 || reader.Position + len > reader.Length)
continue;
int stringLen = (int)len / 2;
if (stringLen > chars.Length)
Array.Resize(ref chars, stringLen);
for (int i = 0; i < stringLen; i++)
chars[i] = (char)reader.ReadUInt16();
if ((len & 1) != 0)
reader.ReadByte();
var s = new string(chars, 0, stringLen);
if (!cachedDict.ContainsKey(s))
cachedDict[s] = offset;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Source stream</param>
/// <param name="name">Name of original file or <c>null</c> if unknown.</param>
public ImageStreamIStream(IImageStream stream, string name)
{
if (stream == null)
throw new ArgumentNullException("stream");
this.stream = stream;
this.name = name ?? string.Empty;
}
/// <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;
}
}
public void AddToFavorites(IImageStream stream)
{
// TODO:
// make an autopersistable stream feature
var dirStream = stream as DirectoryImageStream;
if (dirStream != null)
{
var db = DAL.DatabaseService.GetInstance();
using (var transaction = db.BeginTransaction())
{
var folderRef = new DAL.FolderRefEntity();
folderRef.Path = dirStream.Path;
DAL.DatabaseService.FolderRefRepository.Write(folderRef);
var fav_item = new DAL.FavoritesStreamReference();
fav_item.id = folderRef.Key;
fav_item.TableName = "folder_refs";
DAL.DatabaseService.FavoritesRepository.Write(fav_item);
db.CommitTransaction();
}
}
}
/// <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 StreamHeader(IImageStream reader, bool verify) {
SetStartOffset(reader);
this.offset = reader.ReadUInt32();
this.streamSize = reader.ReadUInt32();
this.name = ReadString(reader, 32, verify);
SetEndoffset(reader);
if (verify && offset + size < offset)
throw new BadImageFormatException("Invalid stream header");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="reader">PE file reader</param>
/// <param name="verify">Verify section</param>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
public ImageDosHeader(IImageStream reader, bool verify) {
SetStartOffset(reader);
ushort sig = reader.ReadUInt16();
if (verify && sig != 0x5A4D)
throw new BadImageFormatException("Invalid DOS signature");
reader.Position = (long)startOffset + 0x3C;
this.ntHeadersOffset = reader.ReadUInt32();
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 ImageNTHeaders(IImageStream reader, bool verify) {
SetStartOffset(reader);
this.signature = reader.ReadUInt32();
if (verify && this.signature != 0x4550)
throw new BadImageFormatException("Invalid NT headers signature");
this.imageFileHeader = new ImageFileHeader(reader, verify);
this.imageOptionalHeader = CreateImageOptionalHeader(reader, verify);
SetEndoffset(reader);
}
/// <summary>
/// Adds a resource
/// </summary>
/// <param name="stream">The resource data</param>
/// <returns>The resource data</returns>
public ByteArrayChunk Add(IImageStream stream) {
if (setOffsetCalled)
throw new InvalidOperationException("SetOffset() has already been called");
var rawData = stream.ReadAllBytes();
length = Utils.AlignUp(length + 4 + (uint)rawData.Length, alignment);
var data = new ByteArrayChunk(rawData);
resources.Add(data);
return data;
}
/// <summary>
/// Creates an IImageOptionalHeader
/// </summary>
/// <param name="reader">PE file reader pointing to the start of the optional header</param>
/// <param name="verify">Verify section</param>
/// <returns>The created IImageOptionalHeader</returns>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
IImageOptionalHeader CreateImageOptionalHeader(IImageStream reader, bool verify) {
ushort magic = reader.ReadUInt16();
reader.Position -= 2;
switch (magic) {
case 0x010B: return new ImageOptionalHeader32(reader, imageFileHeader.SizeOfOptionalHeader, verify);
case 0x020B: return new ImageOptionalHeader64(reader, imageFileHeader.SizeOfOptionalHeader, verify);
default: throw new BadImageFormatException("Invalid optional header magic");
}
}
public MsfStream(IImageStream[] pages, uint length) {
byte[] buf = new byte[length];
int offset = 0;
foreach (var page in pages) {
page.Position = 0;
int len = Math.Min((int)page.Length, (int)(length - offset));
offset += page.Read(buf, offset, len);
}
Content = new MemoryImageStream(0, buf, 0, buf.Length);
}
public void LoadFunctions(PdbReader reader, IImageStream stream) {
stream.Position = 0;
using (var substream = stream.Create(stream.FileOffset + stream.Position, cbSyms))
ReadFunctions(substream);
if (Functions.Count > 0) {
stream.Position += cbSyms + cbOldLines;
using (var substream = stream.Create(stream.FileOffset + stream.Position, cbLines))
ReadLines(reader, substream);
}
}
public ECallListReader(string filename)
{
this.peImage = new PEImage(filename);
this.reader = peImage.CreateFullStream();
this.is32bit = peImage.ImageNTHeaders.OptionalHeader.Magic == 0x010B;
this.ptrSize = is32bit ? 4U : 8;
var last = peImage.ImageSectionHeaders[peImage.ImageSectionHeaders.Count - 1];
this.endRva = (uint)last.VirtualAddress + last.VirtualSize;
this.list = new List<ECClass>();
this.tableFormat = null;
Read();
}
int GetReader_NoLock(uint offset, out IImageStream reader) {
reader = null;
if (!IsValidOffset(offset))
return -1;
reader = GetReader_NoLock(offset);
uint length;
if (!reader.ReadCompressedUInt32(out length))
return -1;
if (reader.Position + length < length || reader.Position + length > reader.Length)
return -1;
return (int)length; // length <= 0x1FFFFFFF so this cast does not make it negative
}
/// <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 ImageFileHeader(IImageStream reader, bool verify) {
SetStartOffset(reader);
this.machine = (Machine)reader.ReadUInt16();
this.numberOfSections = reader.ReadUInt16();
this.timeDateStamp = reader.ReadUInt32();
this.pointerToSymbolTable = reader.ReadUInt32();
this.numberOfSymbols = reader.ReadUInt32();
this.sizeOfOptionalHeader = reader.ReadUInt16();
this.characteristics = (Characteristics)reader.ReadUInt16();
SetEndoffset(reader);
if (verify && this.sizeOfOptionalHeader == 0)
throw new BadImageFormatException("Invalid SizeOfOptionalHeader");
}
public void Read(IImageStream stream) {
stream.Position = 0;
Language = new Guid(stream.ReadBytes(0x10));
LanguageVendor = new Guid(stream.ReadBytes(0x10));
DocumentType = new Guid(stream.ReadBytes(0x10));
CheckSumAlgorithmId = new Guid(stream.ReadBytes(0x10));
var len = stream.ReadInt32();
if (stream.ReadUInt32() != 0)
throw new PdbException("Unexpected value");
CheckSum = stream.ReadBytes(len);
}
/// <summary>
/// Adds a resource
/// </summary>
/// <param name="stream">The resource data</param>
/// <returns>The resource data</returns>
public ByteArrayChunk Add(IImageStream stream)
{
if (setOffsetCalled)
{
throw new InvalidOperationException("SetOffset() has already been called");
}
var rawData = stream.ReadAllBytes();
length = Utils.AlignUp(length + 4 + (uint)rawData.Length, alignment);
var data = new ByteArrayChunk(rawData);
resources.Add(data);
return(data);
}
/// <inheritdoc/>
public void Dispose() {
IDisposable id;
if (win32Resources.IsValueInitialized && (id = win32Resources.Value) != null)
id.Dispose();
if ((id = imageStream) != null)
id.Dispose();
if ((id = imageStreamCreator) != null)
id.Dispose();
win32Resources.Value = null;
imageStream = null;
imageStreamCreator = null;
peType = null;
peInfo = null;
}
/// <summary>
/// Initializes the metadata, tables, streams
/// </summary>
public void Initialize(IImageStream mdStream)
{
InitializeInternal(mdStream);
if (tablesStream == null)
{
throw new BadImageFormatException("Missing MD stream");
}
if (isStandalonePortablePdb && pdbStream == null)
{
throw new BadImageFormatException("Missing #Pdb stream");
}
InitializeNonExistentHeaps();
}
/// <summary>
/// Replace the image at the given index with the given one
/// </summary>
/// <param name="id">Identifier.</param>
/// <param name="newImage">New image.</param>
public void ReplaceImage(int id, IImageStream newImage)
{
FileInfo file = GetImageFileFromIndex(id);
if (file == null || !file.Exists)
{
throw new ArgumentException(String.Format("Image with ID {0} does not exist.", id));
}
using (var stream = file.OpenWrite())
{
newImage.CopyTo(stream);
}
}
/// <summary>
/// Creates an IImageOptionalHeader
/// </summary>
/// <param name="reader">PE file reader pointing to the start of the optional header</param>
/// <param name="verify">Verify section</param>
/// <returns>The created IImageOptionalHeader</returns>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
IImageOptionalHeader CreateImageOptionalHeader(IImageStream reader, bool verify)
{
ushort magic = reader.ReadUInt16();
reader.Position -= 2;
switch (magic)
{
case 0x010B: return(new ImageOptionalHeader32(reader, imageFileHeader.SizeOfOptionalHeader, verify));
case 0x020B: return(new ImageOptionalHeader64(reader, imageFileHeader.SizeOfOptionalHeader, verify));
default: throw new BadImageFormatException("Invalid optional header magic");
}
}
/// <summary>
/// Creates a new <see cref="ISymbolReader"/> instance
/// </summary>
/// <param name="pdbImpl">PDB implementation to use</param>
/// <param name="metaData">.NET metadata. Only need to be non-null if MS COM API should be used</param>
/// <param name="pdbStream">PDB file stream which is now owned by us</param>
/// <returns>A new <see cref="ISymbolReader"/> instance or <c>null</c> if it's not possible
/// to create a <see cref="ISymbolReader"/>.</returns>
public static ISymbolReader Create(PdbImplType pdbImpl, IMetaData metaData, IImageStream pdbStream) {
switch (pdbImpl) {
case PdbImplType.MicrosoftCOM:
return Dss.SymbolReaderCreator.Create(metaData, pdbStream);
case PdbImplType.Managed:
return Managed.SymbolReaderCreator.Create(pdbStream);
default:
if (pdbStream != null)
pdbStream.Dispose();
throw new InvalidOperationException();
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="reader">PE file reader pointing to the start of this section</param>
/// <param name="verify">Verify sections</param>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
public PEInfo(IImageStream reader, bool verify) {
reader.Position = 0;
this.imageDosHeader = new ImageDosHeader(reader, verify);
if (verify && this.imageDosHeader.NTHeadersOffset == 0)
throw new BadImageFormatException("Invalid NT headers offset");
reader.Position = this.imageDosHeader.NTHeadersOffset;
this.imageNTHeaders = new ImageNTHeaders(reader, verify);
reader.Position = (long)this.imageNTHeaders.OptionalHeader.StartOffset + this.imageNTHeaders.FileHeader.SizeOfOptionalHeader;
this.imageSectionHeaders = new ImageSectionHeader[this.imageNTHeaders.FileHeader.NumberOfSections];
for (int i = 0; i < this.imageSectionHeaders.Length; i++)
this.imageSectionHeaders[i] = new ImageSectionHeader(reader, verify);
}
static uint GetEntryPointToken(string filename, out string otherModuleName)
{
otherModuleName = null;
IImageStream cor20HeaderStream = null;
try {
using (var peImage = new PEImage(filename)) {
var dotNetDir = peImage.ImageNTHeaders.OptionalHeader.DataDirectories[14];
if (dotNetDir.VirtualAddress == 0)
{
return(0);
}
if (dotNetDir.Size < 0x48)
{
return(0);
}
var cor20Header = new ImageCor20Header(cor20HeaderStream = peImage.CreateStream(dotNetDir.VirtualAddress, 0x48), true);
if ((cor20Header.Flags & ComImageFlags.NativeEntryPoint) != 0)
{
return(0);
}
uint token = cor20Header.EntryPointToken_or_RVA;
if ((Table)(token >> 24) != Table.File)
{
return(token);
}
using (var mod = ModuleDefMD.Load(peImage)) {
var file = mod.ResolveFile(token & 0x00FFFFFF);
if (file == null || !file.ContainsMetaData)
{
return(0);
}
otherModuleName = file.Name;
return(token);
}
}
}
catch {
}
finally {
if (cor20HeaderStream != null)
{
cor20HeaderStream.Dispose();
}
}
return(0);
}
static Dictionary <long, MethodExportInfo> GetOffsetToExportInfoDictionary(IImageStream reader, IPEImage peImage, ImageDataDirectory exportHdr, CpuArch cpuArch)
{
reader.Position = (long)peImage.ToFileOffset(exportHdr.VirtualAddress);
// Skip Characteristics(4), TimeDateStamp(4), MajorVersion(2), MinorVersion(2), Name(4)
reader.Position += 16;
uint ordinalBase = reader.ReadUInt32();
int numFuncs = reader.ReadInt32();
int numNames = reader.ReadInt32();
long offsetOfFuncs = (long)peImage.ToFileOffset((RVA)reader.ReadUInt32());
long offsetOfNames = (long)peImage.ToFileOffset((RVA)reader.ReadUInt32());
long offsetOfNameIndexes = (long)peImage.ToFileOffset((RVA)reader.ReadUInt32());
var names = ReadNames(reader, peImage, numNames, offsetOfNames, offsetOfNameIndexes);
reader.Position = offsetOfFuncs;
var allInfos = new MethodExportInfo[numFuncs];
var dict = new Dictionary <long, MethodExportInfo>(numFuncs);
for (int i = 0; i < allInfos.Length; i++)
{
var currOffset = reader.Position;
var nextOffset = reader.Position + 4;
uint funcRva = 0;
var rva = (RVA)reader.ReadUInt32();
reader.Position = (long)peImage.ToFileOffset(rva);
bool rvaValid = rva != 0 && cpuArch.TryGetExportedRvaFromStub(reader, peImage, out funcRva);
long funcOffset = rvaValid ? (long)peImage.ToFileOffset((RVA)funcRva) : 0;
var exportInfo = new MethodExportInfo((ushort)(ordinalBase + (uint)i));
if (funcOffset != 0)
{
dict[funcOffset] = exportInfo;
}
allInfos[i] = exportInfo;
reader.Position = nextOffset;
}
foreach (var info in names)
{
int index = info.Index;
if ((uint)index >= (uint)numFuncs)
{
continue;
}
allInfos[index].Ordinal = null;
allInfos[index].Name = info.Name;
}
return(dict);
}
static bool ReadAndCompareBytes(IImageStream stream, long end, byte[] bytes)
{
if (stream.Position + bytes.Length > end)
{
return(false);
}
for (int i = 0; i < bytes.Length; i++)
{
if (stream.ReadByte() != bytes[i])
{
return(false);
}
}
return(true);
}
/// <summary>
/// Creates a new <see cref="ISymbolReader"/> instance
/// </summary>
/// <param name="metaData">.NET metadata</param>
/// <param name="pdbStream">PDB file stream which is now owned by this method</param>
/// <returns>A new <see cref="ISymbolReader"/> instance or <c>null</c> if any of the COM
/// methods fail.</returns>
public static ISymbolReader Create(IMetaData metaData, IImageStream pdbStream)
{
try
{
return(Create(CreateMetaDataStream(metaData), pdbStream));
}
catch
{
if (pdbStream != null)
{
pdbStream.Dispose();
}
throw;
}
}
/// <summary>
/// Creates a new <see cref="ISymbolReader"/> instance
/// </summary>
/// <param name="mdStream">.NET metadata stream which is now owned by this method</param>
/// <param name="pdbFileName">Path to PDB file</param>
/// <returns>A new <see cref="ISymbolReader"/> instance or <c>null</c> if there's no PDB
/// file on disk or if any of the COM methods fail.</returns>
public static ISymbolReader Create(IImageStream mdStream, string pdbFileName)
{
try
{
return(Create(mdStream, OpenImageStream(pdbFileName)));
}
catch
{
if (mdStream != null)
{
mdStream.Dispose();
}
throw;
}
}
public static byte[] ReadBodyFromRva(this MethodDef method)
{
if (MethodDefExt.OriginalMD == null)
{
MethodDefExt.OriginalMD = AssemblyDef.Load(Configuration.AssemblyFilename, (ModuleCreationOptions)null).ManifestModule as ModuleDefMD;
}
IImageStream fullStream = MethodDefExt.OriginalMD.MetaData.PEImage.CreateFullStream();
FileOffset fileOffset = MethodDefExt.OriginalMD.MetaData.PEImage.ToFileOffset(method.RVA);
long num = MethodDefExt.OriginalMD.MetaData.PEImage.ToFileOffset((RVA)MethodDefExt.OriginalMD.TablesStream.ReadMethodRow(method.Rid + 1U).RVA) - fileOffset;
byte[] buffer = new byte[100];
fullStream.Position = (long)(fileOffset + 20L);
fullStream.Read(buffer, 0, buffer.Length);
return(buffer);
}
/// <inheritdoc/>
protected override HotTableStream CreateHotTableStreamImpl()
{
IImageStream stream = null;
try {
stream = fullStream.Clone();
return(new HotTableStreamCLR40(stream, GetHotTableBaseOffset()));
}
catch {
if (stream != null)
{
stream.Dispose();
}
throw;
}
}
/// <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 ImageFileHeader(IImageStream reader, bool verify)
{
SetStartOffset(reader);
this.machine = (Machine)reader.ReadUInt16();
this.numberOfSections = reader.ReadUInt16();
this.timeDateStamp = reader.ReadUInt32();
this.pointerToSymbolTable = reader.ReadUInt32();
this.numberOfSymbols = reader.ReadUInt32();
this.sizeOfOptionalHeader = reader.ReadUInt16();
this.characteristics = (Characteristics)reader.ReadUInt16();
SetEndoffset(reader);
if (verify && this.sizeOfOptionalHeader == 0)
{
throw new BadImageFormatException("Invalid SizeOfOptionalHeader");
}
}
/// <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 ImageSectionHeader(IImageStream reader, bool verify)
{
SetStartOffset(reader);
this.name = reader.ReadBytes(8);
this.virtualSize = reader.ReadUInt32();
this.virtualAddress = (RVA)reader.ReadUInt32();
this.sizeOfRawData = reader.ReadUInt32();
this.pointerToRawData = reader.ReadUInt32();
this.pointerToRelocations = reader.ReadUInt32();
this.pointerToLinenumbers = reader.ReadUInt32();
this.numberOfRelocations = reader.ReadUInt16();
this.numberOfLinenumbers = reader.ReadUInt16();
this.characteristics = reader.ReadUInt32();
SetEndoffset(reader);
displayName = ToString(name);
}
/// <summary>
/// Read the PDB in the specified stream.
/// </summary>
/// <param name="stream">The stream that contains the PDB file</param>
public void Read(IImageStream stream) {
try {
ReadInternal(stream);
}
catch (Exception ex) {
if (ex is PdbException)
throw;
throw new PdbException(ex);
}
finally {
streams = null;
names = null;
strings = null;
modules = null;
}
}
static string ReadString(IImageStream reader, int maxLen, bool verify) {
var origPos = reader.Position;
var sb = new StringBuilder(maxLen);
int i;
for (i = 0; i < maxLen; i++) {
byte b = reader.ReadByte();
if (b == 0)
break;
sb.Append((char)b);
}
if (verify && i == maxLen)
throw new BadImageFormatException("Invalid stream name string");
if (i != maxLen)
reader.Position = origPos + ((i + 1 + 3) & ~3);
return sb.ToString();
}
public void Read(IImageStream stream, long recEnd) {
stream.Position += 4;
var end = stream.ReadUInt32();
stream.Position += 4;
var len = stream.ReadUInt32();
stream.Position += 8;
Token = stream.ReadUInt32();
Address = PdbAddress.ReadAddress(stream);
stream.Position += 1 + 2;
Name = PdbReader.ReadCString(stream);
stream.Position = recEnd;
Root = new DbiScope("", Address.Offset, len);
Root.Read(new RecursionCounter(), stream, end);
FixOffsets(new RecursionCounter(), Root);
}
private ThreadSafe.IList <HotHeapStream> CreateHotHeapStreams2()
{
var list = ThreadSafeListCreator.Create <HotHeapStream>();
try
{
var dirBaseOffs = GetHotHeapDirectoryBaseOffset();
for (var offs = dirBaseOffs; offs + 8 <= endOffset - 8; offs += 8)
{
fullStream.Position = offs;
HeapType heapType;
long hotHeapOffset;
ReadHotHeapDirectory(fullStream, dirBaseOffs, out heapType, out hotHeapOffset);
IImageStream dataStream = null;
HotHeapStream hotHeapStream = null;
try
{
dataStream = fullStream.Clone();
list.Add(hotHeapStream = CreateHotHeapStream(heapType, dataStream, hotHeapOffset));
dataStream = null;
hotHeapStream = null;
}
catch
{
if (hotHeapStream != null)
{
hotHeapStream.Dispose();
}
if (dataStream != null)
{
dataStream.Dispose();
}
throw;
}
}
}
catch
{
foreach (var h in list)
{
h.Dispose();
}
throw;
}
return(list);
}
/// <summary>
/// Creates a new <see cref="ISymbolReader"/> instance
/// </summary>
/// <param name="mdStream">.NET metadata stream which is now owned by this method</param>
/// <param name="pdbData">PDB file data</param>
/// <returns>A new <see cref="ISymbolReader"/> instance or <c>null</c> if any of the COM
/// methods fail.</returns>
public static ISymbolReader Create(IImageStream mdStream, byte[] pdbData)
{
if (pdbData == null)
{
return(null);
}
try {
return(Create(mdStream, MemoryImageStream.Create(pdbData)));
}
catch {
if (mdStream != null)
{
mdStream.Dispose();
}
throw;
}
}
public void Read(IImageStream stream)
{
stream.Position = 0;
Language = new Guid(stream.ReadBytes(0x10));
LanguageVendor = new Guid(stream.ReadBytes(0x10));
DocumentType = new Guid(stream.ReadBytes(0x10));
CheckSumAlgorithmId = new Guid(stream.ReadBytes(0x10));
var len = stream.ReadInt32();
if (stream.ReadUInt32() != 0)
{
throw new PdbException("Unexpected value");
}
CheckSum = stream.ReadBytes(len);
}
public void LoadFunctions(PdbReader reader, IImageStream stream)
{
stream.Position = 0;
using (var substream = stream.Create(stream.FileOffset + stream.Position, cbSyms))
{
ReadFunctions(substream);
}
if (Functions.Count > 0)
{
stream.Position += cbSyms + cbOldLines;
using (var substream = stream.Create(stream.FileOffset + stream.Position, cbLines))
{
ReadLines(reader, substream);
}
}
}
/// <summary>
/// Reads a custom attribute
/// </summary>
/// <param name="module">Owner module</param>
/// <param name="stream">A stream positioned at the the first byte of the CA blob</param>
/// <param name="ctor">Custom attribute constructor</param>
/// <returns>A new <see cref="CustomAttribute"/> instance or <c>null</c> if one of the
/// args is <c>null</c> or if we failed to parse the CA blob</returns>
public static CustomAttribute Read(ModuleDef module, IImageStream stream, ICustomAttributeType ctor)
{
if (stream == null || ctor == null)
{
return(null);
}
try {
using (var reader = new CustomAttributeReader(module, stream, ctor))
return(reader.Read());
}
catch (CABlobParserException) {
return(null);
}
catch (IOException) {
return(null);
}
}
void Populate(IImageStream reader) {
reader.Position = 1;
while (reader.Position < reader.Length) {
uint offset = (uint)reader.Position;
var bytes = reader.ReadBytesUntilByte(0);
if (bytes == null)
break;
reader.ReadByte(); // terminating zero
if (bytes.Length == 0)
continue;
var s = new UTF8String(bytes);
if (!cachedDict.ContainsKey(s))
cachedDict[s] = offset;
}
}
/// <inheritdoc/>
protected override void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (dataReader != null)
{
dataReader.Dispose();
}
if (rsrcReader != null)
{
rsrcReader.Dispose();
}
dataReader = null;
rsrcReader = null;
base.Dispose(disposing);
}
/// <summary>
/// Creates a new <see cref="ISymbolReader"/> instance
/// </summary>
/// <param name="pdbImpl">PDB implementation to use</param>
/// <param name="metaData">.NET metadata. Only need to be non-null if MS COM API should be used</param>
/// <param name="pdbStream">PDB file stream which is now owned by us</param>
/// <returns>A new <see cref="ISymbolReader"/> instance or <c>null</c> if it's not possible
/// to create a <see cref="ISymbolReader"/>.</returns>
public static ISymbolReader Create(PdbImplType pdbImpl, IMetaData metaData, IImageStream pdbStream)
{
switch (pdbImpl)
{
case PdbImplType.MicrosoftCOM:
return(Dss.SymbolReaderCreator.Create(metaData, pdbStream));
case PdbImplType.Managed:
return(Managed.SymbolReaderCreator.Create(pdbStream));
default:
if (pdbStream != null)
{
pdbStream.Dispose();
}
throw new InvalidOperationException();
}
}
void Populate(IImageStream reader) {
reader.Position = 1;
while (reader.Position < reader.Length) {
uint offset = (uint)reader.Position;
uint len;
if (!reader.ReadCompressedUInt32(out len)) {
if (offset == reader.Position)
reader.Position++;
continue;
}
if (len == 0 || reader.Position + len > reader.Length)
continue;
var data = reader.ReadBytes((int)len);
if (!cachedDict.ContainsKey(data))
cachedDict[data] = offset;
}
}
public IActionResult RetrieveImage(int id)
{
IImageStream image = _imageProvider.GetImage(id);
if (image == null)
{
return(BadRequest(new ErrorResponse("No such image")));
}
// We need to copy the image to an internal memory stream in order
// to transfer it out with a byte array. This is probably inefficient
// since we copy once to the filesystem to memory and then from
// memory to HTTP - worth refactoring later
var dataStream = new MemoryStream();
image.CopyTo(dataStream);
return(File(dataStream.ToArray(), image.Format.ContentTypeString()));
}
void ReadFiles(PdbReader reader, Dictionary <long, DbiDocument> documents, IImageStream stream, long end)
{
var begin = stream.Position;
while (stream.Position < end)
{
var id = stream.Position - begin;
var nameId = stream.ReadUInt32();
var len = stream.ReadByte();
/*var type = */ stream.ReadByte();
var doc = reader.GetDocument(nameId);
documents.Add(id, doc);
stream.Position += len;
stream.Position = (stream.Position + 3) & (~3);
}
}
public void Read(RecursionCounter counter, IImageStream stream, uint scopeEnd) {
if (!counter.Increment())
throw new PdbException("Scopes too deep");
while (stream.Position < scopeEnd) {
var size = stream.ReadUInt16();
var begin = stream.Position;
var end = begin + size;
var type = (SymbolType)stream.ReadUInt16();
DbiScope child = null;
uint? childEnd = null;
switch (type) {
case SymbolType.S_BLOCK32: {
stream.Position += 4;
childEnd = stream.ReadUInt32();
var len = stream.ReadUInt32();
var addr = PdbAddress.ReadAddress(stream);
var name = PdbReader.ReadCString(stream);
child = new DbiScope(name, addr.Offset, len);
break;
}
case SymbolType.S_UNAMESPACE:
Namespaces.Add(new DbiNamespace(PdbReader.ReadCString(stream)));
break;
case SymbolType.S_MANSLOT: {
var variable = new DbiVariable();
variable.Read(stream);
Variables.Add(variable);
break;
}
}
stream.Position = end;
if (child != null) {
child.Read(counter, stream, childEnd.Value);
Children.Add(child);
child = null;
}
}
counter.Decrement();
if (stream.Position != scopeEnd)
Debugger.Break();
}
/// <summary>
/// Read the PDB in the specified stream.
/// </summary>
/// <param name="stream">The stream that contains the PDB file</param>
public void Read(IImageStream stream)
{
try {
ReadInternal(stream);
}
catch (Exception ex) {
if (ex is PdbException)
{
throw;
}
throw new PdbException(ex);
}
finally {
streams = null;
names = null;
strings = null;
modules = null;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="reader">PE file reader pointing to the start of this section</param>
/// <param name="verify">Verify sections</param>
/// <exception cref="BadImageFormatException">Thrown if verification fails</exception>
public PEInfo(IImageStream reader, bool verify)
{
reader.Position = 0;
this.imageDosHeader = new ImageDosHeader(reader, verify);
if (verify && this.imageDosHeader.NTHeadersOffset == 0)
{
throw new BadImageFormatException("Invalid NT headers offset");
}
reader.Position = this.imageDosHeader.NTHeadersOffset;
this.imageNTHeaders = new ImageNTHeaders(reader, verify);
reader.Position = (long)this.imageNTHeaders.OptionalHeader.StartOffset + this.imageNTHeaders.FileHeader.SizeOfOptionalHeader;
this.imageSectionHeaders = new ImageSectionHeader[this.imageNTHeaders.FileHeader.NumberOfSections];
for (int i = 0; i < this.imageSectionHeaders.Length; i++)
{
this.imageSectionHeaders[i] = new ImageSectionHeader(reader, verify);
}
}
/// <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;
}
}
static string ReadUnicodeString(IImageStream stream, long end)
{
var sb = new StringBuilder();
for (;;)
{
if (stream.Position + 2 > end)
{
return(null);
}
var c = (char)stream.ReadUInt16();
if (c == 0)
{
break;
}
sb.Append(c);
}
return(sb.ToString());
}
public void Read(IImageStream stream, long recEnd)
{
stream.Position += 4;
var end = stream.ReadUInt32();
stream.Position += 4;
var len = stream.ReadUInt32();
stream.Position += 8;
Token = stream.ReadUInt32();
Address = PdbAddress.ReadAddress(stream);
stream.Position += 1 + 2;
Name = PdbReader.ReadCString(stream);
stream.Position = recEnd;
Root = new DbiScope("", Address.Offset, len);
Root.Read(new RecursionCounter(), stream, end);
FixOffsets(new RecursionCounter(), Root);
}
void Populate(IImageStream reader)
{
var chars = new char[0x200];
reader.Position = 1;
while (reader.Position < reader.Length)
{
uint offset = (uint)reader.Position;
uint len;
if (!reader.ReadCompressedUInt32(out len))
{
if (offset == reader.Position)
{
reader.Position++;
}
continue;
}
if (len == 0 || reader.Position + len > reader.Length)
{
continue;
}
int stringLen = (int)len / 2;
if (stringLen > chars.Length)
{
Array.Resize(ref chars, stringLen);
}
for (int i = 0; i < stringLen; i++)
{
chars[i] = (char)reader.ReadUInt16();
}
if ((len & 1) != 0)
{
reader.ReadByte();
}
var s = new string(chars, 0, stringLen);
if (!cachedDict.ContainsKey(s))
{
cachedDict[s] = offset;
}
}
}
/// <summary>
/// Create a standalone portable PDB <see cref="MetaData"/> instance
/// </summary>
/// <param name="mdStream">Metadata stream</param>
/// <param name="verify"><c>true</c> if we should verify that it's a .NET PE file</param>
/// <returns>A new <see cref="MetaData"/> instance</returns>
internal static MetaData CreateStandalonePortablePDB(IImageStream mdStream, bool verify)
{
MetaData md = null;
try {
var mdHeader = new MetaDataHeader(mdStream, verify);
if (verify)
{
foreach (var sh in mdHeader.StreamHeaders)
{
if (sh.Offset + sh.StreamSize < sh.Offset || sh.Offset + sh.StreamSize > mdStream.Length)
{
throw new BadImageFormatException("Invalid stream header");
}
}
}
switch (GetMetaDataType(mdHeader.StreamHeaders))
{
case MetaDataType.Compressed:
md = new CompressedMetaData(mdHeader, true);
break;
case MetaDataType.ENC:
md = new ENCMetaData(mdHeader, true);
break;
default:
throw new BadImageFormatException("No #~ or #- stream found");
}
md.Initialize(mdStream);
return(md);
}
catch {
if (md != null)
{
md.Dispose();
}
throw;
}
}
/// <summary>
/// Creates a new <see cref="ISymbolReader"/> instance
/// </summary>
/// <param name="pdbStream">PDB file stream which is now owned by this method</param>
/// <returns>A new <see cref="ISymbolReader"/> instance or <c>null</c>.</returns>
public static ISymbolReader Create(IImageStream pdbStream) {
if (pdbStream == null)
return null;
try {
var pdbReader = new PdbReader();
pdbReader.Read(pdbStream);
return pdbReader;
}
catch (IOException) {
}
catch (UnauthorizedAccessException) {
}
catch (SecurityException) {
}
finally {
if (pdbStream != null)
pdbStream.Dispose();
}
return null;
}
public void Read(IImageStream stream) {
stream.Position += 34;
StreamId = stream.ReadUInt16();
cbSyms = stream.ReadUInt32();
cbOldLines = stream.ReadUInt32();
cbLines = stream.ReadUInt32();
stream.Position += 16;
if ((int)cbSyms < 0)
cbSyms = 0;
if ((int)cbOldLines < 0)
cbOldLines = 0;
if ((int)cbLines < 0)
cbLines = 0;
ModuleName = PdbReader.ReadCString(stream);
ObjectName = PdbReader.ReadCString(stream);
stream.Position = (stream.Position + 3) & (~3);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Metadata stream</param>
public PinnedMetaData(IImageStream stream) {
this.stream = stream;
var umStream = stream as UnmanagedMemoryImageStream;
if (umStream != null) {
this.address = umStream.StartAddress;
GC.SuppressFinalize(this); // no GCHandle so finalizer isn't needed
}
else {
var memStream = stream as MemoryImageStream;
if (memStream != null) {
this.streamData = memStream.DataArray;
this.gcHandle = GCHandle.Alloc(this.streamData, GCHandleType.Pinned);
this.address = new IntPtr(this.gcHandle.AddrOfPinnedObject().ToInt64() + memStream.DataOffset);
}
else {
this.streamData = stream.ReadAllBytes();
this.gcHandle = GCHandle.Alloc(this.streamData, GCHandleType.Pinned);
this.address = this.gcHandle.AddrOfPinnedObject();
}
}
}
void ReadFunctions(IImageStream stream) {
if (stream.ReadUInt32() != 4)
throw new PdbException("Invalid signature");
while (stream.Position < stream.Length) {
var size = stream.ReadUInt16();
var begin = stream.Position;
var end = begin + size;
var type = (SymbolType)stream.ReadUInt16();
switch (type) {
case SymbolType.S_GMANPROC:
case SymbolType.S_LMANPROC:
var func = new DbiFunction();
func.Read(stream, end);
Functions.Add(func);
break;
default:
stream.Position = end;
break;
}
}
}
/// <inheritdoc/>
protected override void Dispose(bool disposing) {
if (!disposing)
return;
if (dataReader != null)
dataReader.Dispose();
if (rsrcReader != null)
rsrcReader.Dispose();
dataReader = null;
rsrcReader = null;
base.Dispose(disposing);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="peImage">The PE image</param>
/// <param name="rsrcReader">Reader for the whole Win32 resources section (usually
/// the .rsrc section) or <c>null</c> if we should create one from the resource data
/// directory in the optional header. This instance owns the reader.</param>
public Win32ResourcesPE(IPEImage peImage, IBinaryReader rsrcReader) {
this.rvaConverter = peImage;
this.dataReader = peImage.CreateFullStream();
if (rsrcReader != null)
this.rsrcReader = rsrcReader;
else {
var dataDir = peImage.ImageNTHeaders.OptionalHeader.DataDirectories[2];
if (dataDir.VirtualAddress != 0 && dataDir.Size != 0)
this.rsrcReader = peImage.CreateStream(dataDir.VirtualAddress, dataDir.Size);
else
this.rsrcReader = MemoryImageStream.CreateEmpty();
}
Initialize();
}
