public static string GetFullAssemblyName(this SRM.AssemblyReference reference, MetadataReader reader) { string publicKey = "null"; if (!reference.PublicKeyOrToken.IsNil) { if ((reference.Flags & AssemblyFlags.PublicKey) != 0) { publicKey = CalculatePublicKeyToken(reference.PublicKeyOrToken, reader); } else { publicKey = reader.GetBlobBytes(reference.PublicKeyOrToken).ToHexString(8); } } string properties = ""; if ((reference.Flags & AssemblyFlags.Retargetable) != 0) { properties = ", Retargetable=true"; } return($"{reader.GetString(reference.Name)}, " + $"Version={reference.Version}, " + $"Culture={(reference.Culture.IsNil ? "neutral" : reader.GetString(reference.Culture))}, " + $"PublicKeyToken={publicKey}{properties}"); }
public AssemblyRefEntry(PEFile module, AssemblyReferenceHandle handle) { this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset; this.module = module; this.metadata = module.Metadata; this.handle = handle; this.assemblyRef = metadata.GetAssemblyReference(handle); }
private void InitializeTypeForwarder(ForwarderKey key, TypeForwarder record) { Cts.Ecma.EcmaModule module = key.Module; Ecma.MetadataReader reader = module.MetadataReader; Ecma.ExportedType exportedType = reader.GetExportedType(key.ExportedType); record.Name = HandleString(reader.GetString(exportedType.Name)); switch (exportedType.Implementation.Kind) { case Ecma.HandleKind.AssemblyReference: { string ns = reader.GetString(exportedType.Namespace); NamespaceDefinition namespaceDefinition = HandleNamespaceDefinition(module, ns); Ecma.AssemblyReference assemblyRef = reader.GetAssemblyReference((Ecma.AssemblyReferenceHandle)exportedType.Implementation); AssemblyName refName = new AssemblyName { ContentType = (AssemblyContentType)((int)(assemblyRef.Flags & AssemblyFlags.ContentTypeMask) >> 9), Flags = (AssemblyNameFlags)(assemblyRef.Flags & ~AssemblyFlags.ContentTypeMask), CultureName = reader.GetString(assemblyRef.Culture), Name = reader.GetString(assemblyRef.Name), Version = assemblyRef.Version, }; if ((assemblyRef.Flags & AssemblyFlags.PublicKey) != 0) { refName.SetPublicKey(reader.GetBlobBytes(assemblyRef.PublicKeyOrToken)); } else { refName.SetPublicKeyToken(reader.GetBlobBytes(assemblyRef.PublicKeyOrToken)); } record.Scope = HandleScopeReference(refName); namespaceDefinition.TypeForwarders.Add(record); } break; case Ecma.HandleKind.ExportedType: { TypeForwarder scope = HandleTypeForwarder(module, (Ecma.ExportedTypeHandle)exportedType.Implementation); record.Scope = scope.Scope; scope.NestedTypes.Add(record); } break; default: throw new BadImageFormatException(); } }
private TypeForwarder HandleTypeForwarder(Cts.Ecma.EcmaModule module, Ecma.ExportedType exportedType) { Ecma.MetadataReader reader = module.MetadataReader; string name = reader.GetString(exportedType.Name); TypeForwarder result; switch (exportedType.Implementation.Kind) { case Ecma.HandleKind.AssemblyReference: { string ns = reader.GetString(exportedType.Namespace); NamespaceDefinition namespaceDefinition = HandleNamespaceDefinition(module, ns); Ecma.AssemblyReference assemblyRef = reader.GetAssemblyReference((Ecma.AssemblyReferenceHandle)exportedType.Implementation); AssemblyName refName = new AssemblyName { ContentType = (AssemblyContentType)((int)(assemblyRef.Flags & AssemblyFlags.ContentTypeMask) >> 9), Flags = (AssemblyNameFlags)(assemblyRef.Flags & ~AssemblyFlags.ContentTypeMask), CultureName = reader.GetString(assemblyRef.Culture), Name = reader.GetString(assemblyRef.Name), Version = assemblyRef.Version, }; result = new TypeForwarder { Name = HandleString(name), Scope = HandleScopeReference(refName), }; namespaceDefinition.TypeForwarders.Add(result); } break; case Ecma.HandleKind.ExportedType: { TypeForwarder scope = HandleTypeForwarder(module, reader.GetExportedType((Ecma.ExportedTypeHandle)exportedType.Implementation)); result = new TypeForwarder { Name = HandleString(name), Scope = scope.Scope, }; scope.NestedTypes.Add(result); } break; default: throw new BadImageFormatException(); } return(result); }
public static bool TryGetFullAssemblyName(this SRM.AssemblyReference reference, MetadataReader reader, out string assemblyName) { try { assemblyName = GetFullAssemblyName(reference, reader); return(true); } catch (BadImageFormatException) { assemblyName = null; return(false); } }
public AssemblyReference(PEFile module, AssemblyReferenceHandle handle) { if (module == null) { throw new ArgumentNullException(nameof(module)); } if (handle.IsNil) { throw new ArgumentNullException(nameof(handle)); } Metadata = module.Metadata; Handle = handle; entry = Metadata.GetAssemblyReference(handle); }
public AssemblyReference(MetadataReader metadata, AssemblyReferenceHandle handle) { if (metadata == null) { throw new ArgumentNullException(nameof(metadata)); } if (handle.IsNil) { throw new ArgumentNullException(nameof(handle)); } Metadata = metadata; Handle = handle; entry = metadata.GetAssemblyReference(handle); }
public static string GetFullAssemblyName(this MetadataReader metadataReader, AssemblyReference assemblyReference) { var assemblyName = metadataReader.GetString(assemblyReference.Name); var culture = metadataReader.GetString(assemblyReference.Culture); if (string.IsNullOrEmpty(culture)) { culture = "neutral"; } var version = assemblyReference.Version; var publicKeyTokenBytes = metadataReader.GetBytes(assemblyReference.PublicKeyOrToken); var publicKeyToken = Conversion.ByteArrayToHexString(publicKeyTokenBytes); publicKeyToken = string.IsNullOrEmpty(publicKeyToken) ? "null" : publicKeyToken; var fullAssemblyName = string.Format( "{0}, Version={1}, Culture={2}, PublicKeyToken={3}", assemblyName, version.ToString(), culture, publicKeyToken); return fullAssemblyName; }
public static string GetFullAssemblyName(this SRM.AssemblyReference reference, MetadataReader reader) { StringBuilder builder = new StringBuilder(); builder.Append(reader.GetString(reference.Name)); builder.Append(", Version="); builder.Append(reference.Version); builder.Append(", Culture="); if (reference.Culture.IsNil) { builder.Append("neutral"); } else { builder.Append(reader.GetString(reference.Culture)); } if (reference.PublicKeyOrToken.IsNil) { builder.Append(", PublicKeyToken=null"); } else if ((reference.Flags & AssemblyFlags.PublicKey) != 0) { builder.Append(", PublicKeyToken="); builder.Append(CalculatePublicKeyToken(reference.PublicKeyOrToken, reader)); } else { builder.Append(", PublicKeyToken="); builder.AppendHexString(reader.GetBlobReader(reference.PublicKeyOrToken)); } if ((reference.Flags & AssemblyFlags.Retargetable) != 0) { builder.Append(", Retargetable=true"); } return(builder.ToString()); }
public static AssemblyReferenceInformation FormatAssemblyInfo(this MetadataReader metadataReader, AssemblyReference assemblyReference) { var name = metadataReader.GetString(assemblyReference.Name); return metadataReader.FormatAssemblyInfo(name, assemblyReference.Culture, assemblyReference.PublicKeyOrToken, assemblyReference.Version); }
private static AssemblyReference[] GetAssemblyReferences(MetadataReader reader) { var count = reader.GetTableRowCount(TableIndex.AssemblyRef); var references = new AssemblyReference[count]; for (int i = 0; i < count; i++) { var reference = reader.GetAssemblyReference(MetadataTokens.AssemblyReferenceHandle(i + 1)); references[i] = new AssemblyReference(reader.GetString(reference.Name), reference.Version); } return references.ToArray(); }
public AssemblyInfo(string path, string name, Version version, AssemblyReference[] references, string[] moduleReferences) { Path = path; Name = name; Version = version; References = references; ModuleReferences = moduleReferences; State = CheckState.Unchecked; }
private bool ShouldIgnore(AssemblyReference reference) { Version toIgnore; return ignoredReferences.TryGetValue(reference.Name, out toIgnore) && (toIgnore == null || toIgnore >= reference.Version); }
private bool IsSameResolutionScope(MetadataReader referenceMetadata, MetadataReader newMetadata, AssemblyReference referenceResolutionScope, AssemblyReference newResolutionScope) { return IsSameAssembly(referenceMetadata, newMetadata, referenceResolutionScope, newResolutionScope); }
private bool IsSameAssembly(MetadataReader referenceMetadata, MetadataReader newMetadata, AssemblyReference referenceAssemblyReference, AssemblyReference newAssemblyReference) { string referenceName = referenceMetadata.GetString(referenceAssemblyReference.Name); string newName = newMetadata.GetString(newAssemblyReference.Name); if (!string.Equals(referenceName, newName, StringComparison.Ordinal)) return false; string referenceCulture = referenceMetadata.GetString(referenceAssemblyReference.Culture); string newCulture = newMetadata.GetString(newAssemblyReference.Culture); if (!string.Equals(referenceCulture, newCulture, StringComparison.Ordinal)) return false; Version referenceVersion = referenceAssemblyReference.Version; Version newVersion = newAssemblyReference.Version; if (referenceVersion != newVersion) return false; byte[] referencePublicKeyOrToken = referenceMetadata.GetBlobBytes(referenceAssemblyReference.PublicKeyOrToken); byte[] newPublicKeyOrToken = newMetadata.GetBlobBytes(newAssemblyReference.PublicKeyOrToken); if (referencePublicKeyOrToken != null) { if (newPublicKeyOrToken == null || referencePublicKeyOrToken.Length != newPublicKeyOrToken.Length) return false; for (int i = 0; i < referencePublicKeyOrToken.Length; i++) { if (referencePublicKeyOrToken[i] != newPublicKeyOrToken[i]) return false; } } else if (newPublicKeyOrToken != null) { return false; } return true; }
private void CheckResolutionScope(MetadataReader referenceMetadata, MetadataReader newMetadata, AssemblyReference referenceResolutionScope, AssemblyReference newResolutionScope) { if (!IsSameAssembly(referenceMetadata, newMetadata, referenceResolutionScope, newResolutionScope)) throw new NotImplementedException("ResolutionScope assembly reference changed."); }