private void ImportCustomAttributesNames() { _customAttributes = new List <string>(); AssemblyDefinition def = _reader.GetAssemblyDefinition(); CustomAttributeHandleCollection col = def.GetCustomAttributes(); foreach (CustomAttributeHandle handle in col) { EntityHandle ctorHandle = _reader.GetCustomAttribute(handle).Constructor; if (ctorHandle.Kind != HandleKind.MemberReference) { continue; } EntityHandle mHandle = _reader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent; if (mHandle.Kind != HandleKind.TypeReference) { continue; } string type = GetTypeName((TypeReferenceHandle)mHandle); _customAttributes.Add(type); } }
/// <summary> /// Construct the strong assembly name from metadata /// </summary> internal static string GetAssemblyStrongName(MetadataReader metadataReader) { AssemblyDefinition assemblyDefinition = metadataReader.GetAssemblyDefinition(); string asmName = metadataReader.GetString(assemblyDefinition.Name); string asmVersion = assemblyDefinition.Version.ToString(); string asmCulture = metadataReader.GetString(assemblyDefinition.Culture); asmCulture = (asmCulture == string.Empty) ? "neutral" : asmCulture; AssemblyHashAlgorithm hashAlgorithm = assemblyDefinition.HashAlgorithm; BlobHandle blobHandle = assemblyDefinition.PublicKey; BlobReader blobReader = metadataReader.GetBlobReader(blobHandle); string publicKeyTokenString = "null"; // Extract public key token only if PublicKey exists in the metadata if (blobReader.Length > 0) { byte[] publickey = blobReader.ReadBytes(blobReader.Length); HashAlgorithm hashImpl = null; switch (hashAlgorithm) { case AssemblyHashAlgorithm.Sha1: hashImpl = SHA1.Create(); break; case AssemblyHashAlgorithm.MD5: hashImpl = MD5.Create(); break; case AssemblyHashAlgorithm.Sha256: hashImpl = SHA256.Create(); break; case AssemblyHashAlgorithm.Sha384: hashImpl = SHA384.Create(); break; case AssemblyHashAlgorithm.Sha512: hashImpl = SHA512.Create(); break; default: throw new NotSupportedException(); } byte[] publicKeyHash = hashImpl.ComputeHash(publickey); byte[] publicKeyTokenBytes = new byte[8]; // Note that, the low 8 bytes of the hash of public key in reverse order is the public key tokens. for (int i = 1; i <= 8; i++) { publicKeyTokenBytes[i - 1] = publicKeyHash[publicKeyHash.Length - i]; } // Convert bytes to hex format strings in lower case. publicKeyTokenString = BitConverter.ToString(publicKeyTokenBytes).Replace("-", string.Empty).ToLowerInvariant(); } string strongAssemblyName = string.Format(CultureInfo.InvariantCulture, "{0}, Version={1}, Culture={2}, PublicKeyToken={3}", asmName, asmVersion, asmCulture, publicKeyTokenString); return strongAssemblyName; }
private static AssemblyIdentity ReadAssemblyIdentity(SystemMetadataReader metadataReader) { var assemblyDefinition = metadataReader.GetAssemblyDefinition(); var name = metadataReader.GetString(assemblyDefinition.Name); var version = assemblyDefinition.Version; var cultureName = metadataReader.GetString(assemblyDefinition.Culture); var publicKeyOrToken = metadataReader.GetBlobContent(assemblyDefinition.PublicKey); var flags = assemblyDefinition.Flags; var hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0; return(new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey: hasPublicKey)); }
private static AssemblyIdentity ReadAssemblyIdentity(SystemMetadataReader metadataReader) { var assemblyDefinition = metadataReader.GetAssemblyDefinition(); string name = metadataReader.GetString(assemblyDefinition.Name); Version version = assemblyDefinition.Version; string cultureName = metadataReader.GetString(assemblyDefinition.Culture); ImmutableArray <byte> publicKeyOrToken = metadataReader.GetBlobContent(assemblyDefinition.PublicKey); AssemblyFlags flags = assemblyDefinition.Flags; bool hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0; return(new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey: hasPublicKey)); }
public DependencyFinderEngineHelper(MetadataReader metadataReader, string assemblyPath) { _reader = metadataReader; _assemblyLocation = assemblyPath; MemberDependency = new List<MemberDependency>(); CallingAssembly = _reader.GetAssemblyInfo(assemblyPath); // Get assembly info var assemblyDefinition = _reader.GetAssemblyDefinition(); _currentAssemblyInfo = _reader.FormatAssemblyInfo(assemblyDefinition); _currentAssemblyName = _reader.GetString(assemblyDefinition.Name); }
internal static unsafe AssemblyName GetAssemblyName(string assemblyFile) { if (assemblyFile == null) { throw new ArgumentNullException(nameof(assemblyFile)); } FileStream? fileStream = null; MemoryMappedFile? mappedFile = null; MemoryMappedViewAccessor?accessor = null; PEReader?peReader = null; try { try { // Create stream because CreateFromFile(string, ...) uses FileShare.None which is too strict fileStream = new FileStream(assemblyFile, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 1, useAsync: false); if (fileStream.Length == 0) { throw new BadImageFormatException(SR.PEImageDoesNotHaveMetadata, assemblyFile); } mappedFile = MemoryMappedFile.CreateFromFile( fileStream, null, fileStream.Length, MemoryMappedFileAccess.Read, HandleInheritability.None, true); accessor = mappedFile.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read); SafeMemoryMappedViewHandle?safeBuffer = accessor.SafeMemoryMappedViewHandle; peReader = new PEReader((byte *)safeBuffer.DangerousGetHandle(), (int)safeBuffer.ByteLength); MetadataReader mdReader = peReader.GetMetadataReader(MetadataReaderOptions.None); AssemblyName assemblyName = mdReader.GetAssemblyDefinition().GetAssemblyName(); return(assemblyName); } finally { peReader?.Dispose(); accessor?.Dispose(); mappedFile?.Dispose(); fileStream?.Dispose(); } } catch (InvalidOperationException ex) { throw new BadImageFormatException(ex.Message); } }
public DependencyFinderEngineHelper(IDependencyFilter assemblyFilter, MetadataReader metadataReader, IAssemblyFile file) { _assemblyFilter = assemblyFilter; _reader = metadataReader; _assemblyLocation = file.Name; MemberDependency = new List<MemberDependency>(); CallingAssembly = new AssemblyInfo { AssemblyIdentity = metadataReader.FormatAssemblyInfo().ToString(), FileVersion = file.Version ?? string.Empty, TargetFrameworkMoniker = metadataReader.GetTargetFrameworkMoniker() ?? string.Empty }; // Get assembly info var assemblyDefinition = _reader.GetAssemblyDefinition(); _currentAssemblyInfo = _reader.FormatAssemblyInfo(assemblyDefinition); _currentAssemblyName = _reader.GetString(assemblyDefinition.Name); }
/// <summary>Load our fields from the metadata of the file as represented by the provided metadata reader.</summary> /// <param name="metadataReader">The metadata reader for the CLI file this represents.</param> private void LoadManagedAssemblyMetadata(MetadataReader metadataReader) { AssemblyDefinition assemblyDefinition = metadataReader.GetAssemblyDefinition(); // Set the internal and original names based on the file name. _internalName = _originalFilename = Path.GetFileName(_fileName); // Set the product version based on the assembly's version (this may be overwritten // later in the method). Version productVersion = assemblyDefinition.Version; _productVersion = productVersion.ToString(); _productMajor = productVersion.Major; _productMinor = productVersion.Minor; _productBuild = productVersion.Build != -1 ? productVersion.Build : 0; _productPrivate = productVersion.Revision != -1 ? productVersion.Revision : 0; // "Language Neutral" is used on Win32 for unknown language identifiers. _language = "Language Neutral"; // Set other fields to default values in case they're not overwritten by attributes _companyName = string.Empty; _comments = string.Empty; _fileDescription = " "; // this is what the managed compiler outputs when value isn't set _fileVersion = string.Empty; _legalCopyright = " "; // this is what the managed compiler outputs when value isn't set _legalTrademarks = string.Empty; _productName = string.Empty; _privateBuild = string.Empty; _specialBuild = string.Empty; // Be explicit about initialization to suppress warning about fields not being set _isDebug = false; _isPatched = false; _isPreRelease = false; _isPrivateBuild = false; _isSpecialBuild = false; bool sawAssemblyInformationalVersionAttribute = false; // Everything else is parsed from assembly attributes MetadataStringComparer comparer = metadataReader.StringComparer; foreach (CustomAttributeHandle attrHandle in assemblyDefinition.GetCustomAttributes()) { CustomAttribute attr = metadataReader.GetCustomAttribute(attrHandle); StringHandle typeNamespaceHandle = default(StringHandle), typeNameHandle = default(StringHandle); if (TryGetAttributeName(metadataReader, attr, out typeNamespaceHandle, out typeNameHandle) && comparer.Equals(typeNamespaceHandle, "System.Reflection")) { if (comparer.Equals(typeNameHandle, "AssemblyCompanyAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _companyName); } else if (comparer.Equals(typeNameHandle, "AssemblyCopyrightAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _legalCopyright); } else if (comparer.Equals(typeNameHandle, "AssemblyDescriptionAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _comments); } else if (comparer.Equals(typeNameHandle, "AssemblyFileVersionAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _fileVersion); ParseVersion(_fileVersion, out _fileMajor, out _fileMinor, out _fileBuild, out _filePrivate); } else if (comparer.Equals(typeNameHandle, "AssemblyInformationalVersionAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _productVersion); ParseVersion(_productVersion, out _productMajor, out _productMinor, out _productBuild, out _productPrivate); sawAssemblyInformationalVersionAttribute = true; } else if (comparer.Equals(typeNameHandle, "AssemblyProductAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _productName); } else if (comparer.Equals(typeNameHandle, "AssemblyTrademarkAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _legalTrademarks); } else if (comparer.Equals(typeNameHandle, "AssemblyTitleAttribute")) { GetStringAttributeArgumentValue(metadataReader, attr, ref _fileDescription); } } } // When the managed compiler sees an [AssemblyVersion(...)] attribute, it uses that to set // both the assembly version and the product version in the Win32 resources. If it doesn't // see an [AssemblyVersion(...)], then it sets the assembly version to 0.0.0.0, however it // sets the product version in the Win32 resources to whatever was defined in the // [AssemblyFileVersionAttribute(...)] if there was one (unless there is an AssemblyInformationalVersionAttribute, // in which case it always uses that for the product version). Without parsing the Win32 resources, // we can't differentiate these two cases, so given the rarity of explicitly setting an // assembly's version number to 0.0.0.0, we assume that if it is 0.0.0.0 then the attribute // wasn't specified and we use the file version. if (!sawAssemblyInformationalVersionAttribute && _productVersion == "0.0.0.0") { _productVersion = _fileVersion; _productMajor = _fileMajor; _productMinor = _fileMinor; _productBuild = _fileBuild; _productPrivate = _filePrivate; } }
private static AssemblyIdentity ReadAssemblyIdentity(SystemMetadataReader metadataReader) { var assemblyDefinition = metadataReader.GetAssemblyDefinition(); string name = metadataReader.GetString(assemblyDefinition.Name); Version version = assemblyDefinition.Version; string cultureName = metadataReader.GetString(assemblyDefinition.Culture); ImmutableArray<byte> publicKeyOrToken = metadataReader.GetBlobContent(assemblyDefinition.PublicKey); AssemblyFlags flags = assemblyDefinition.Flags; bool hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0; return new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey: hasPublicKey); }
private EcmaFormatRuntimeAssembly(MetadataReader reader) { AssemblyDefinition = reader.GetAssemblyDefinition(); MetadataReader = reader; }
public EcmaAssembly(TypeSystemContext context, PEReader peReader, MetadataReader metadataReader) : base(context, peReader, metadataReader) { _assemblyDefinition = metadataReader.GetAssemblyDefinition(); }
/// <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, MetadataReader mdReader, bool unSign) { CorHeader header = peReader.PEHeaders.CorHeader; var expectedStrongNameFlag = unSign ? CorFlags.StrongNameSigned : 0; var actualStrongNameFlag = header.Flags & CorFlags.StrongNameSigned; if (expectedStrongNameFlag != actualStrongNameFlag) { Console.Error.WriteLine($"PE file is {(unSign ? "not" : "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; }
private void CheckAssemblyProperties(MetadataReader referenceMetadata, MetadataReader newMetadata) { AssemblyDefinition referenceAssemblyDefinition = referenceMetadata.GetAssemblyDefinition(); AssemblyDefinition newAssemblyDefinition = newMetadata.GetAssemblyDefinition(); string referenceName = referenceMetadata.GetString(referenceAssemblyDefinition.Name); string newName = newMetadata.GetString(newAssemblyDefinition.Name); if (!string.Equals(referenceName, newName, StringComparison.Ordinal)) _logger.Report(AssemblyNameMustNotBeChanged.CreateMessage()); string referenceCulture = referenceMetadata.GetString(referenceAssemblyDefinition.Culture); string newCulture = referenceMetadata.GetString(newAssemblyDefinition.Culture); if (!string.Equals(referenceCulture, newCulture, StringComparison.Ordinal)) throw new NotImplementedException("Assembly culture changed."); if (!referenceAssemblyDefinition.PublicKey.IsNil) { // adding a public key is supported, but removing or changing it is not. var referencePublicKey = referenceMetadata.GetBlobContent(referenceAssemblyDefinition.PublicKey); var newPublicKey = newMetadata.GetBlobContent(newAssemblyDefinition.PublicKey); if (!referencePublicKey.SequenceEqual(newPublicKey)) _logger.Report(PublicKeyMustNotBeChanged.CreateMessage()); } }
internal EcmaAssembly(TypeSystemContext context, PEReader peReader, MetadataReader metadataReader, PdbSymbolReader pdbReader) : base(context, peReader, metadataReader, pdbReader) { _assemblyDefinition = metadataReader.GetAssemblyDefinition(); }