static void Main(string[] args) { if (args.Length == 0 || new[] {"/?", "-?", "-h", "--help"}.Any(x => string.Equals(args[0], x, StringComparison.OrdinalIgnoreCase))) { PrintUsage(); return; } foreach (var fileName in args) { Console.WriteLine(fileName); Console.WriteLine(new string('*', 80)); try { using (var stream = File.OpenRead(fileName)) using (var peFile = new PEReader(stream)) { var metadataReader = peFile.GetMetadataReader(); var visualizer = new MetadataVisualizer(metadataReader, Console.Out); visualizer.Visualize(); } } catch (Exception ex) { Console.WriteLine(ex.Message); } } }
public PE(string fileName) { FileName = Path.GetFullPath(fileName); Uri = new Uri(FileName); IsPEFile = false; try { _fs = File.OpenRead(FileName); byte byteRead = (byte)_fs.ReadByte(); if (byteRead != 'M') { return; } byteRead = (byte)_fs.ReadByte(); if (byteRead != 'Z') { return; } _fs.Seek(0, SeekOrigin.Begin); _peReader = new PEReader(_fs); PEHeaders = _peReader.PEHeaders; IsPEFile = true; } catch (IOException e) { LoadException = e; } catch (BadImageFormatException e) { LoadException = e; } catch (UnauthorizedAccessException e) { LoadException = e; } if (IsPEFile) { m_pImage = new SafePointer(_peReader.GetEntireImage().GetContent().ToBuilder().ToArray()); if (IsManaged) { _metadataReader = _peReader.GetMetadataReader(); } } }
/// <summary> /// Returns true if the PE file meets all of the pre-conditions to be Open Source Signed. /// Returns false and logs msbuild errors otherwise. /// </summary> private static bool Validate(PEReader peReader) { if (!peReader.HasMetadata) { Console.Error.WriteLine("PE file is not a managed module."); return false; } var mdReader = peReader.GetMetadataReader(); if (!mdReader.IsAssembly) { Console.Error.WriteLine("PE file is not an assembly."); return false; } CorHeader header = peReader.PEHeaders.CorHeader; if ((header.Flags & CorFlags.StrongNameSigned) == CorFlags.StrongNameSigned) { Console.Error.WriteLine("PE file is already strong-name signed."); return false; } if ((header.StrongNameSignatureDirectory.Size <= 0) || mdReader.GetAssemblyDefinition().PublicKey.IsNil) { Console.Error.WriteLine("PE file is not a delay-signed assembly."); return false; } return true; }
public InspectableAssembly(string filename, ParseContext context) { Stream = File.OpenRead(filename); Pe = new PEReader(Stream); Reader = Pe.GetMetadataReader(); Context = context; }
public static AssemblyIdentity TryGetAssemblyIdentity(string filePath) { try { using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete)) using (var peReader = new PEReader(stream)) { var metadataReader = peReader.GetMetadataReader(); AssemblyDefinition assemblyDefinition = metadataReader.GetAssemblyDefinition(); string name = metadataReader.GetString(assemblyDefinition.Name); Version version = assemblyDefinition.Version; StringHandle cultureHandle = assemblyDefinition.Culture; string cultureName = (!cultureHandle.IsNil) ? metadataReader.GetString(cultureHandle) : null; AssemblyFlags flags = assemblyDefinition.Flags; bool hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0; BlobHandle publicKeyHandle = assemblyDefinition.PublicKey; ImmutableArray<byte> publicKeyOrToken = !publicKeyHandle.IsNil ? metadataReader.GetBlobBytes(publicKeyHandle).AsImmutableOrNull() : default(ImmutableArray<byte>); return new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey); } } catch { } return null; }
public void OpenNativeImage() { using (var reader = new PEReader(File.OpenRead(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "kernel32.dll")))) { Assert.False(reader.HasMetadata); Assert.True(reader.PEHeaders.IsDll); Assert.False(reader.PEHeaders.IsExe); Assert.Throws<InvalidOperationException>(() => reader.GetMetadataReader()); } }
public override bool Execute() { if (Assemblies == null || Assemblies.Length == 0) return true; List<ITaskItem> references = new List<ITaskItem>(); List<ITaskItem> nativeLibs = new List<ITaskItem>(); foreach (var assemblyItem in Assemblies) { try { if (!File.Exists(assemblyItem.ItemSpec)) { Log.LogError($"File {assemblyItem.ItemSpec} does not exist, ensure you have built libraries before building the package."); continue; } using (PEReader peReader = new PEReader(new FileStream(assemblyItem.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read))) { MetadataReader reader = peReader.GetMetadataReader(); foreach (var handle in reader.AssemblyReferences) { AssemblyReference reference = reader.GetAssemblyReference(handle); TaskItem referenceItem = new TaskItem(reader.GetString(reference.Name)); assemblyItem.CopyMetadataTo(referenceItem); referenceItem.SetMetadata("Version", reference.Version.ToString()); referenceItem.SetMetadata("AssemblyVersion", reference.Version.ToString()); references.Add(referenceItem); } for (int i = 1, count = reader.GetTableRowCount(TableIndex.ModuleRef); i <= count; i++) { var moduleRef = reader.GetModuleReference(MetadataTokens.ModuleReferenceHandle(i)); var moduleName = reader.GetString(moduleRef.Name); TaskItem nativeLib = new TaskItem(moduleName); assemblyItem.CopyMetadataTo(nativeLib); nativeLibs.Add(nativeLib); } } } catch (InvalidOperationException) { // Ignore invalid assemblies } } ReferencedAssemblies = references.ToArray(); ReferencedNativeLibraries = nativeLibs.ToArray(); return true; }
public static ISymUnmanagedReader CreateReader(Stream pdbStream, Stream peStreamOpt = null) { if (peStreamOpt != null) { var peReader = new PEReader(peStreamOpt); return CreateReader(pdbStream, peReader.GetMetadataReader(), peReader); } else { return CreateReader(pdbStream, null, null); } }
public void IL_LazyLoad() { var peStream = new MemoryStream(TestResources.Misc.Members); using (var reader = new PEReader(peStream, PEStreamOptions.LeaveOpen)) { var md = reader.GetMetadataReader(); var il = reader.GetMethodBody(md.GetMethodDefinition(MetadataTokens.MethodDefinitionHandle(1)).RelativeVirtualAddress); Assert.Equal(new byte[] { 0, 42 }, il.GetILBytes()); Assert.Equal(8, il.MaxStack); } }
public static AssemblyInfo GetAssemblyInfo(string path) { using (var peReader = new PEReader(new FileStream(path, FileMode.Open, FileAccess.Read))) { var contractReader = peReader.GetMetadataReader(); var assembly = contractReader.GetAssemblyDefinition(); var name = contractReader.GetString(assembly.Name); var version = assembly.Version; var references = GetAssemblyReferences(contractReader); return new AssemblyInfo(path, name, version, references); } }
public override bool Execute() { Log.LogMessage(MessageImportance.High, "About to inspect {0} test assemblies.", TestBinaries.Length); var perfTests = new List<ITaskItem>(); foreach (var testBinary in TestBinaries) { Log.LogMessage(MessageImportance.Low, "Inspecting assembly {0}.", testBinary.ItemSpec); using (var stream = File.OpenRead(testBinary.ItemSpec)) { using (var peFile = new PEReader(stream)) { if(!peFile.HasMetadata){ continue; } var mdReader = peFile.GetMetadataReader(); foreach (var asmRefHandle in mdReader.AssemblyReferences) { var asmRef = mdReader.GetAssemblyReference(asmRefHandle); var asmRefName = mdReader.GetString(asmRef.Name); // if an assembly contains a reference to xunit.performance.core // then it contains at least one performance test. if (string.Compare(asmRefName, "xunit.performance.core", StringComparison.OrdinalIgnoreCase) == 0) { var fileName = (GetFullPaths) ? Path.GetFullPath(testBinary.ItemSpec) : Path.GetFileNameWithoutExtension(testBinary.ItemSpec); perfTests.Add(new TaskItem(fileName)); Log.LogMessage("+ Assembly {0} contains one or more performance tests.", fileName); break; } } } } } if (perfTests.Count > 0) { PerfTestAssemblies = perfTests.ToArray(); Log.LogMessage(MessageImportance.High, "Found {0} assemblies containing performance tests.", perfTests.Count); } else { Log.LogWarning("Didn't find any performance tests."); } return true; }
public void BasicValidation() { using (var peStream = new MemoryStream()) { var ilBuilder = new BlobBuilder(); var metadataBuilder = new MetadataBuilder(); var entryPoint = BasicValidationEmit(metadataBuilder, ilBuilder); WritePEImage(peStream, metadataBuilder, ilBuilder, entryPoint); peStream.Position = 0; var r = new PEReader(peStream); var h = r.PEHeaders; var mdReader = r.GetMetadataReader(); } }
/// <summary> /// Returns true if the PE file meets all of the pre-conditions to be Open Source Signed. /// Returns false and logs msbuild errors otherwise. /// </summary> private static bool IsPublicSigned(PEReader peReader) { if (!peReader.HasMetadata) { return false; } var mdReader = peReader.GetMetadataReader(); if (!mdReader.IsAssembly) { return false; } CorHeader header = peReader.PEHeaders.CorHeader; return (header.Flags & CorFlags.StrongNameSigned) == CorFlags.StrongNameSigned; }
/// <remarks> /// Based on https://gist.github.com/nguerrera/72444715c7ea0b40addb /// </remarks> public static byte[] GetILBytes(this MethodInfo methodInfo) { #if NET45 return methodInfo.GetMethodBody().GetILAsByteArray(); #else var metadataToken = methodInfo.GetMetadataToken(); using (var stream = File.OpenRead(methodInfo.DeclaringType.GetTypeInfo().Assembly.Location)) using (var peReader = new PEReader(stream)) { var metadataReader = peReader.GetMetadataReader(); var methodHandle = MetadataTokens.MethodDefinitionHandle(metadataToken); var methodDefinition = metadataReader.GetMethodDefinition(methodHandle); var methodBody = peReader.GetMethodBody(methodDefinition.RelativeVirtualAddress); return methodBody.GetILBytes(); } #endif }
public static string GetAssemblyAttributeValue(string assemblyPath, string attributeName) { if (!File.Exists(assemblyPath)) { return null; } using (var stream = File.OpenRead(assemblyPath)) using (var peReader = new PEReader(stream)) { if (!peReader.HasMetadata) { return null; } var mdReader = peReader.GetMetadataReader(); var attrs = mdReader.GetAssemblyDefinition().GetCustomAttributes() .Select(ah => mdReader.GetCustomAttribute(ah)); foreach (var attr in attrs) { var ctorHandle = attr.Constructor; if (ctorHandle.Kind != HandleKind.MemberReference) { continue; } var container = mdReader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent; var name = mdReader.GetTypeReference((TypeReferenceHandle)container).Name; if (!string.Equals(mdReader.GetString(name), attributeName)) { continue; } var arguments = GetFixedStringArguments(mdReader, attr); if (arguments.Count == 1) { return arguments[0]; } } } return null; }
/// <summary> /// Given a path to an assembly, identifies files in the same directory /// that could satisfy the assembly's dependencies. May throw. /// </summary> /// <remarks> /// Dependencies are identified by simply checking the name of an assembly /// reference against a file name; if they match the file is considered a /// dependency. Other factors, such as version, culture, public key, etc., /// are not considered, and so the returned collection may include items that /// cannot in fact satisfy the original assembly's dependencies. /// </remarks> /// <exception cref="IOException">If the file at <paramref name="filePath"/> does not exist or cannot be accessed.</exception> /// <exception cref="BadImageFormatException">If the file is not an assembly or is somehow corrupted.</exception> public static ImmutableArray<string> FindAssemblySet(string filePath) { Debug.Assert(filePath != null); Debug.Assert(PathUtilities.IsAbsolute(filePath)); Queue<string> workList = new Queue<string>(); HashSet<string> assemblySet = new HashSet<string>(StringComparer.OrdinalIgnoreCase); workList.Enqueue(filePath); while (workList.Count > 0) { string assemblyPath = workList.Dequeue(); if (!assemblySet.Add(assemblyPath)) { continue; } var directory = Path.GetDirectoryName(assemblyPath); using (var reader = new PEReader(FileUtilities.OpenRead(assemblyPath))) { var metadataReader = reader.GetMetadataReader(); var assemblyReferenceHandles = metadataReader.AssemblyReferences; foreach (var handle in assemblyReferenceHandles) { var reference = metadataReader.GetAssemblyReference(handle); var referenceName = metadataReader.GetString(reference.Name); string referencePath = Path.Combine(directory, referenceName + ".dll"); if (!assemblySet.Contains(referencePath) && File.Exists(referencePath)) { workList.Enqueue(referencePath); } } } } return ImmutableArray.CreateRange(assemblySet); }
public static IList<IMetadataEmbeddedReference> GetEmbeddedReferences(this PEReader reader) { var items = new List<IMetadataEmbeddedReference>(); var mdReader = reader.GetMetadataReader(); foreach (var resourceHandle in mdReader.ManifestResources) { var resource = mdReader.GetManifestResource(resourceHandle); var resourceName = mdReader.GetString(resource.Name); if (resourceName.StartsWith("AssemblyNeutral/") && resourceName.EndsWith(".dll")) { var buffer = GetEmbeddedResourceContents(reader, resource); using (var nestedPeReader = new PEReader(new MemoryStream(buffer))) { try { // Skip dlls that aren't managed if (!nestedPeReader.HasMetadata) { continue; } } catch (BadImageFormatException) { continue; } var nestedMdReader = nestedPeReader.GetMetadataReader(); var assemblyDef = nestedMdReader.GetAssemblyDefinition(); var assemblyName = nestedMdReader.GetString(assemblyDef.Name); items.Add(new EmbeddedMetadataReference(assemblyName, buffer)); } } } return items; }
private static IList<string> GetReferences(byte[] buffer) { var references = new List<string>(); using (var stream = new MemoryStream(buffer)) using (var peReader = new PEReader(stream)) { var reader = peReader.GetMetadataReader(); foreach (var a in reader.AssemblyReferences) { var reference = reader.GetAssemblyReference(a); var referenceName = reader.GetString(reference.Name); references.Add(referenceName); } return references; } }
public static Version GetAssemblyVersion(string assemblyPath) { Version result = null; try { using (PEReader peReader = new PEReader(new FileStream(assemblyPath, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read))) { if (peReader.HasMetadata) { MetadataReader reader = peReader.GetMetadataReader(); result = reader.GetAssemblyDefinition().Version; } } } catch (BadImageFormatException) { // not a PE } return result; }
// ----------------------------- // ---- PAL layer ends here ---- // ----------------------------- /// <summary>Attempt to load our fields from the metadata of the file, if it's a managed assembly.</summary> /// <returns>true if the file is a managed assembly; otherwise, false.</returns> private bool TryLoadManagedAssemblyMetadata() { try { // Try to load the file using the managed metadata reader using (FileStream assemblyStream = File.OpenRead(_fileName)) using (PEReader peReader = new PEReader(assemblyStream)) { if (peReader.HasMetadata) { MetadataReader metadataReader = peReader.GetMetadataReader(); if (metadataReader.IsAssembly) { LoadManagedAssemblyMetadata(metadataReader); return true; } } } } catch (BadImageFormatException) { } return false; }
// ----------------------------- // ---- PAL layer ends here ---- // ----------------------------- /// <summary>Attempt to load our fields from the metadata of the file, if it's a managed assembly.</summary> /// <returns>true if the file is a managed assembly; otherwise, false.</returns> private bool TryLoadManagedAssemblyMetadata() { try { // Try to load the file using the managed metadata reader using (FileStream assemblyStream = new FileStream(_fileName, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 0x1000, useAsync: false)) using (PEReader peReader = new PEReader(assemblyStream)) { if (peReader.HasMetadata) { MetadataReader metadataReader = peReader.GetMetadataReader(); if (metadataReader.IsAssembly) { LoadManagedAssemblyMetadata(metadataReader); return true; } } } } catch (BadImageFormatException) { } return false; }
public static Version GetAssemblyVersion(Stream assemblyStream) { Version result = null; try { using (PEReader peReader = new PEReader(assemblyStream, PEStreamOptions.LeaveOpen)) { if (peReader.HasMetadata) { MetadataReader reader = peReader.GetMetadataReader(); if (reader.IsAssembly) { result = reader.GetAssemblyDefinition().Version; } } } } catch (BadImageFormatException) { // not a PE } return result; }
internal static bool IsAssemblyServiceable(string assemblyPath) { if (!File.Exists(assemblyPath)) { return false; } using (var stream = File.OpenRead(assemblyPath)) using (var peReader = new PEReader(stream)) { if (!peReader.HasMetadata) { return false; } var mdReader = peReader.GetMetadataReader(); var attrs = mdReader.GetAssemblyDefinition().GetCustomAttributes() .Select(ah => mdReader.GetCustomAttribute(ah)); foreach (var attr in attrs) { var ctorHandle = attr.Constructor; if (ctorHandle.Kind != HandleKind.MemberReference) { continue; } var container = mdReader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent; var name = mdReader.GetTypeReference((TypeReferenceHandle)container).Name; if (!string.Equals(mdReader.GetString(name), "AssemblyMetadataAttribute")) { continue; } var arguments = GetFixedStringArguments(mdReader, attr); if (arguments.Count == 2 && string.Equals(arguments[0], "Serviceable", StringComparison.OrdinalIgnoreCase) && string.Equals(arguments[1], "True", StringComparison.OrdinalIgnoreCase)) { return true; } } } return false; }
/// <summary> /// Given a path get the CLR runtime version of the file /// </summary> /// <param name="path">path to the file</param> /// <returns>The CLR runtime version or empty if the path does not exist.</returns> private static string TryGetRuntimeVersion(string path) { try { using (FileStream stream = File.OpenRead(path)) using (PEReader peReader = new PEReader(stream)) { return peReader.GetMetadataReader().MetadataVersion; } } catch (Exception) { return string.Empty; } }
public void CustomDebugEntryPoint_EXE() { var source = @"class M { static void Main() { } } class C { static void F<S>() { } }"; var c = CreateCompilationWithMscorlib(source, options: TestOptions.DebugExe); var f = c.GetMember<MethodSymbol>("C.F"); c.VerifyPdb(@" <symbols> <entryPoint declaringType=""C"" methodName=""F"" /> <methods/> </symbols>", debugEntryPoint: f, options: PdbToXmlOptions.ExcludeScopes | PdbToXmlOptions.ExcludeSequencePoints | PdbToXmlOptions.ExcludeCustomDebugInformation); var peReader = new PEReader(c.EmitToArray(debugEntryPoint: f)); int peEntryPointToken = peReader.PEHeaders.CorHeader.EntryPointTokenOrRelativeVirtualAddress; var mdReader = peReader.GetMetadataReader(); var methodDef = mdReader.GetMethodDefinition((MethodDefinitionHandle)MetadataTokens.Handle(peEntryPointToken)); Assert.Equal("Main", mdReader.GetString(methodDef.Name)); }
public void CanReadFromSameMemoryMappedPEReaderInParallel() { // See http://roslyn.codeplex.com/workitem/299 // // This simulates the use case where something is holding on // to a PEReader and prepared to produce a MetadataReader // on demand for callers on different threads. // using (var stream = GetTemporaryAssemblyLargeEnoughToBeMemoryMapped()) { Assert.InRange(stream.Length, StreamMemoryBlockProvider.MemoryMapThreshold + 1, int.MaxValue); for (int i = 0; i < 1000; i++) { stream.Position = 0; using (var peReader = new PEReader(stream, PEStreamOptions.LeaveOpen)) { Parallel.For(0, 4, _ => { peReader.GetMetadataReader(); }); } } } }
public void Metadata_LazyLoad() { var peStream = new MemoryStream(TestResources.Misc.Members); using (var reader = new PEReader(peStream, PEStreamOptions.LeaveOpen)) { var md = reader.GetMetadataReader(); var method = md.GetMethodDefinition(MetadataTokens.MethodDefinitionHandle(1)); Assert.Equal("MC1", md.GetString(method.Name)); } }
private static List<TypeInfo> GetTypeInfoList(string assemblyPath) { using (var stream = File.OpenRead(assemblyPath)) using (var peReader = new PEReader(stream)) { var metadataReader = peReader.GetMetadataReader(); return GetTypeInfoList(metadataReader); } }
public void Metadata_EagerLoad() { var peStream = new MemoryStream(TestResources.Misc.Members); using (var reader = new PEReader(peStream, PEStreamOptions.LeaveOpen | PEStreamOptions.PrefetchMetadata)) { var md = reader.GetMetadataReader(); var method = md.GetMethodDefinition(MetadataTokens.MethodDefinitionHandle(1)); Assert.Equal("MC1", md.GetString(method.Name)); Assert.Throws<InvalidOperationException>(() => reader.GetEntireImage()); Assert.Throws<InvalidOperationException>(() => reader.GetMethodBody(method.RelativeVirtualAddress)); } }
private AssemblyName GetAssemblyName(string fullPath) { using (var stream = PortableShim.File.OpenRead(fullPath)) { using (var peReader = new PEReader(stream)) { var reader = peReader.GetMetadataReader(); var assemblyDef = reader.GetAssemblyDefinition(); var name = reader.GetString(assemblyDef.Name); var cultureName = assemblyDef.Culture.IsNil ? null : reader.GetString(assemblyDef.Culture); var publicKeyOrToken = reader.GetBlobContent(assemblyDef.PublicKey); var hasPublicKey = !publicKeyOrToken.IsEmpty; if (publicKeyOrToken.IsEmpty) { publicKeyOrToken = default(ImmutableArray<byte>); } var identity = new AssemblyIdentity( name: name, version: assemblyDef.Version, cultureName: cultureName, publicKeyOrToken: publicKeyOrToken, hasPublicKey: hasPublicKey, isRetargetable: (assemblyDef.Flags & AssemblyFlags.Retargetable) != 0, contentType: (AssemblyContentType)((int)(assemblyDef.Flags & AssemblyFlags.ContentTypeMask) >> 9)); return new AssemblyName(identity.GetDisplayName()); } } }