public void FromMetadataStream_NonZeroStart() { var stream = new MemoryStream(); stream.WriteByte(0xff); stream.Write(PortablePdbs.DocumentsPdb, 0, PortablePdbs.DocumentsPdb.Length); stream.WriteByte(0xff); stream.WriteByte(0xff); stream.Position = 1; var PortablePdbReader1 = MetadataReaderProvider.FromMetadataStream(stream, MetadataStreamOptions.LeaveOpen, PortablePdbs.DocumentsPdb.Length); Assert.Equal(PortablePdbs.DocumentsPdb.Length, PortablePdbReader1.GetMetadataReader().Block.Length); var reader1 = PortablePdbReader1.GetMetadataReader(); Assert.Equal(13, reader1.Documents.Count); stream.Position = 1; var PortablePdbReader2 = MetadataReaderProvider.FromMetadataStream(stream, MetadataStreamOptions.LeaveOpen | MetadataStreamOptions.PrefetchMetadata, PortablePdbs.DocumentsPdb.Length); Assert.Equal(PortablePdbs.DocumentsPdb.Length, PortablePdbReader2.GetMetadataReader().Block.Length); var reader2 = PortablePdbReader2.GetMetadataReader(); Assert.Equal(13, reader2.Documents.Count); }
public void FromMetadataStream1() { Assert.Throws <ArgumentNullException>(() => MetadataReaderProvider.FromMetadataStream(null, MetadataStreamOptions.Default)); var invalid = new MemoryStream(new byte[] { 1, 2, 3, 4 }); // the stream should not be disposed if the arguments are bad Assert.Throws <ArgumentOutOfRangeException>(() => MetadataReaderProvider.FromMetadataStream(invalid, (MetadataStreamOptions)int.MaxValue)); Assert.True(invalid.CanRead); // prefetching metadata doesn't create a reader yet, so no exception is thrown: var badReader = MetadataReaderProvider.FromMetadataStream(invalid, MetadataStreamOptions.PrefetchMetadata | MetadataStreamOptions.LeaveOpen); Assert.True(invalid.CanRead); invalid.Position = 0; Assert.Throws <BadImageFormatException>(() => badReader.GetMetadataReader()); // valid metadata: var valid = new MemoryStream(PortablePdbs.DocumentsPdb); var PortablePdbReader = MetadataReaderProvider.FromMetadataStream(valid, MetadataStreamOptions.Default); Assert.True(valid.CanRead); PortablePdbReader.Dispose(); Assert.False(valid.CanRead); }
private static GenerationData ReadDelta(string metadataPath, string ilPathOpt) { byte[] ilDelta; try { ilDelta = (ilPathOpt != null) ? File.ReadAllBytes(ilPathOpt) : null; } catch (Exception e) { Console.WriteLine($"Error reading '{ilPathOpt}': {e.Message}"); return(null); } MetadataReaderProvider mdProvider; try { var stream = File.OpenRead(metadataPath); if (!IsManagedMetadata(stream)) { throw new NotSupportedException("File format not supported"); } mdProvider = MetadataReaderProvider.FromMetadataStream(stream); } catch (Exception e) { Console.WriteLine($"Error reading '{metadataPath}': {e.Message}"); return(null); } return(new GenerationData(mdProvider, mdProvider.GetMetadataReader(), ilDelta: ilDelta)); }
public void Test_CanGetMetaDataProviderFromStreamForPdb() { string peFilePath = Path.GetFullPath("../../../../../artefacts/test_debug.pdb"); var file = File.OpenRead(peFilePath); var mdProvider = MetadataReaderProvider.FromMetadataStream(file); Assert.NotNull(mdProvider); }
public void Test_CanGetEntrypointAdressTableStringFromPdb() { string peFilePath = Path.GetFullPath("../../../../../artefacts/test_debug.pdb"); var file = File.OpenRead(peFilePath); var mdProvider = MetadataReaderProvider.FromMetadataStream(file); var mdReader = mdProvider.GetMetadataReader(); var table = Helpers.Table(mdReader.DebugMetadataHeader.EntryPoint); Assert.Equal("MethodDef", table); }
public void Test_CanGetEntrypointAddressStringFromPdb() { string peFilePath = Path.GetFullPath("../../../../../artefacts/test_debug.pdb"); var file = File.OpenRead(peFilePath); var mdProvider = MetadataReaderProvider.FromMetadataStream(file); var mdReader = mdProvider.GetMetadataReader(); var address = Helpers.AddressString(mdReader, mdReader.DebugMetadataHeader.EntryPoint); Assert.Equal("0x06000001", address); }
private static GenerationData ReadFile(string path, bool embeddedPdb) { try { var generation = new GenerationData(); var stream = File.OpenRead(path); if (IsPE(stream)) { var peReader = new PEReader(stream); generation.PEReaderOpt = peReader; if (embeddedPdb) { var embeddedEntries = peReader.ReadDebugDirectory().Where(entry => entry.Type == DebugDirectoryEntryType.EmbeddedPortablePdb).ToArray(); if (embeddedEntries.Length == 0) { throw new InvalidDataException("No embedded pdb found"); } if (embeddedEntries.Length > 1) { throw new InvalidDataException("Multiple entries in Debug Directory Table of type EmbeddedPortablePdb"); } var provider = peReader.ReadEmbeddedPortablePdbDebugDirectoryData(embeddedEntries[0]); generation.MetadataReader = provider.GetMetadataReader(); generation.MemoryOwner = provider; } else { generation.MetadataReader = peReader.GetMetadataReader(); generation.MemoryOwner = peReader; } } else if (IsManagedMetadata(stream)) { var mdProvider = MetadataReaderProvider.FromMetadataStream(stream); generation.MetadataReader = mdProvider.GetMetadataReader(); generation.MemoryOwner = mdProvider; } else { throw new NotSupportedException("File format not supported"); } return(generation); } catch (Exception e) { Console.WriteLine($"Error reading '{path}': {e.Message}"); return(null); } }
public bool EnC(byte[] meta, byte[] pdb) { var asmStream = new MemoryStream(meta); MetadataReader asmMetadataReader = MetadataReaderProvider.FromMetadataStream(asmStream).GetMetadataReader(); var pdbStream = new MemoryStream(pdb); MetadataReader pdbMetadataReader = MetadataReaderProvider.FromPortablePdbStream(pdbStream).GetMetadataReader(); enCMetadataReader.Add(asmMetadataReader); enCMetadataReader.Add(pdbMetadataReader); PopulateEnC(asmMetadataReader, pdbMetadataReader); return(true); }
/// <summary> /// Opens metadata section of the assembly file produced by the compiler. /// </summary> /// <param name="prefetch"> /// True to prefetch all metadata from the assembly and close the underlying stream on return, /// otherwise keeps the underlying stream open until the returned <see cref="MetadataReaderProvider"/> is disposed. /// </param> /// <returns> /// Instance of <see cref="MetadataReaderProvider"/>, which owns the opened metadata and must be disposed once the caller is done reading the data, /// or null if the assembly is not available. /// </returns> /// <exception cref="BadImageFormatException">Invalid format of the assembly data.</exception> /// <exception cref="InvalidOperationException">The stream returned by <see cref="OpenAssemblyStreamChecked"/> does not support read and seek operations.</exception> /// <exception cref="Exception">Error while reading assembly data.</exception> public virtual MetadataReaderProvider OpenAssemblyMetadata(bool prefetch) { var peStream = OpenAssemblyStreamChecked(); if (peStream != null) { PEHeaders peHeaders; using (var peReader = new PEReader(peStream, PEStreamOptions.LeaveOpen)) { peHeaders = peReader.PEHeaders; } peStream.Position = peHeaders.MetadataStartOffset; return(MetadataReaderProvider.FromMetadataStream( peStream, prefetch ? MetadataStreamOptions.PrefetchMetadata : MetadataStreamOptions.Default, size: peHeaders.MetadataSize)); } return(null); }
public void GetMetadataReader_FromMetadataStream() { TestGetMetadataReader(MetadataReaderProvider.FromMetadataStream(new MemoryStream(BuildMetadataImage().ToArray()))); }
public void GetMetadataReader_EmptyStream() { var provider = MetadataReaderProvider.FromMetadataStream(new MemoryStream(), MetadataStreamOptions.PrefetchMetadata); Assert.Throws <BadImageFormatException>(() => provider.GetMetadataReader()); }
public void FromMetadataStream2() { AssertExtensions.Throws <ArgumentException>("stream", () => MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: false, canSeek: false, canWrite: false))); AssertExtensions.Throws <ArgumentException>("stream", () => MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: true, canSeek: false, canWrite: false))); MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: true, canSeek: true, canWrite: false)); }
public static MetadataReaderProvider GetMetadataReaderProviderFromFileStream(FileStream fileStream) { return(MetadataReaderProvider.FromMetadataStream(fileStream)); }
public void FromMetadataStream2() { Assert.Throws <ArgumentException>(() => MetadataReaderProvider.FromMetadataStream(new TestStream(canRead: false, canSeek: false, canWrite: false))); Assert.Throws <ArgumentException>(() => MetadataReaderProvider.FromMetadataStream(new TestStream(canRead: true, canSeek: false, canWrite: false))); MetadataReaderProvider.FromMetadataStream(new TestStream(canRead: true, canSeek: true, canWrite: false)); }