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()); }
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(); }