private Assembly LoadAssembly(PEReader pe, AssemblyName name = null)
{
MetadataReader reader = pe.GetMetadataReader();
if (!reader.IsAssembly)
{
throw new InvalidDataException("Specified assembly must be an assembly!");
}
if (name != null && !AsmNameComparer.Equals(name, reader.GetAssemblyDefinition().GetAssemblyName()))
{
throw new ArgumentException("Resolved assembly doesn't match the embedded assembly name!");
}
name = reader.GetAssemblyDefinition().GetAssemblyName();
if (_key_pairs.TryGetValue(new ByteData(name.GetPublicKey()), out StrongNameKeyPair kp))
{
name.KeyPair = kp;
}
name.SetPublicKey(null);
AssemblyTracker tracker = new AssemblyTracker(name);
BuildReferences(reader, tracker);
return(null);
}
string[] GetInternalsVisibleTo()
{
var result = LazyInit.VolatileRead(ref this.internalsVisibleTo);
if (result != null)
{
return(result);
}
if (metadata.IsAssembly)
{
var list = new List <string>();
foreach (var attrHandle in metadata.GetAssemblyDefinition().GetCustomAttributes())
{
var attr = metadata.GetCustomAttribute(attrHandle);
if (attr.IsKnownAttribute(metadata, KnownAttribute.InternalsVisibleTo))
{
var attrValue = attr.DecodeValue(this.TypeProvider);
if (attrValue.FixedArguments.Length == 1)
{
if (attrValue.FixedArguments[0].Value is string s)
{
list.Add(GetShortName(s));
}
}
}
}
result = list.ToArray();
}
else
{
result = Empty <string> .Array;
}
return(LazyInit.GetOrSet(ref this.internalsVisibleTo, result));
}
private void WriteAssembly()
{
if (reader.IsAssembly)
{
AddHeader(
"Name",
"Version",
"Culture",
"PublicKey",
"Flags",
"HashAlgorithm"
);
var entry = reader.GetAssemblyDefinition();
AddRow(
Literal(entry.Name),
entry.Version.Major + "." + entry.Version.Minor + "." + entry.Version.Revision + "." + entry.Version.Build,
Literal(entry.Culture),
Literal(entry.PublicKey),
EnumValue <int>(entry.Flags),
EnumValue <int>(entry.HashAlgorithm)
);
WriteRows("Assembly (0x20):");
}
}
public EcmaModule GetModuleFromPath(string filePath)
{
// This method is not expected to be called frequently. Linear search is acceptable.
foreach (var entry in _moduleData)
{
if (entry.Value.Path == filePath)
{
return(entry.Key);
}
}
EcmaModule module = new EcmaModule(this, new PEReader(File.OpenRead(filePath)));
MetadataReader metadataReader = module.MetadataReader;
string simpleName = metadataReader.GetString(metadataReader.GetAssemblyDefinition().Name);
if (_modules.ContainsKey(simpleName))
{
throw new FileNotFoundException("Module with same simple name already exists " + filePath);
}
AddModule(simpleName, filePath, module);
return(module);
}
public EcmaModule GetModuleForSimpleName(string simpleName)
{
EcmaModule existingModule;
if (_modules.TryGetValue(simpleName, out existingModule))
{
return(existingModule);
}
string filePath;
if (!InputFilePaths.TryGetValue(simpleName, out filePath))
{
if (!ReferenceFilePaths.TryGetValue(simpleName, out filePath))
{
throw new FileNotFoundException("Assembly not found: " + simpleName);
}
}
EcmaModule module = new EcmaModule(this, new PEReader(File.OpenRead(filePath)));
MetadataReader metadataReader = module.MetadataReader;
string actualSimpleName = metadataReader.GetString(metadataReader.GetAssemblyDefinition().Name);
if (!actualSimpleName.Equals(simpleName, StringComparison.OrdinalIgnoreCase))
{
throw new FileNotFoundException("Assembly name does not match filename " + filePath);
}
AddModule(simpleName, filePath, module);
return(module);
}
protected override ResolvedAssembly ParseAssembly(
ResolveOperation resolveOperation,
FilePath path,
PEReader peReader,
MetadataReader metadataReader)
{
var resolvedAssembly = base.ParseAssembly(resolveOperation, path, peReader, metadataReader);
foreach (var attrHandle in metadataReader.GetAssemblyDefinition().GetCustomAttributes())
{
var attr = metadataReader.GetCustomAttribute(attrHandle);
if (attr.Constructor.Kind != HandleKind.MemberReference)
{
continue;
}
var ctor = metadataReader.GetMemberReference((MemberReferenceHandle)attr.Constructor);
var typeReference = metadataReader.GetTypeReference((TypeReferenceHandle)ctor.Parent);
var integrationType = typeof(EvaluationContextManagerIntegrationAttribute);
if (metadataReader.GetString(typeReference.Namespace) == integrationType.Namespace &&
metadataReader.GetString(typeReference.Name) == integrationType.Name)
{
return(resolvedAssembly.With(
hasIntegration: true,
externalDependencies: resolvedAssembly.ExternalDependencies));
}
}
return(resolvedAssembly);
}
private static FrameworkName GetTargetFrameworkName(string filePath)
{
using (var stream = File.OpenRead(filePath))
using (var pereader = new PEReader(stream))
{
if (pereader.HasMetadata)
{
MetadataReader metadataReader = pereader.GetMetadataReader();
var attrs = metadataReader.GetAssemblyDefinition().GetCustomAttributes().Select(ah => metadataReader.GetCustomAttribute(ah));
foreach (var attr in attrs)
{
var ctorHandle = attr.Constructor;
if (ctorHandle.Kind != HandleKind.MemberReference)
{
continue;
}
var container = metadataReader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent;
var name = metadataReader.GetTypeReference((TypeReferenceHandle)container).Name;
if (!string.Equals(metadataReader.GetString(name), "TargetFrameworkAttribute"))
{
continue;
}
return(new FrameworkName(GetFixedStringArguments(metadataReader, attr)));
}
}
}
return(null);
}
public MetadataAssembly(PEReader peReader, MetadataReader metadata, string path)
{
Metadata = metadata;
_assembly = metadata.GetAssemblyDefinition();
_path = path;
_peReader = peReader;
}
private static void WriteAssemblyToXml(MetadataReader metaReader, XmlTextWriter xmlWriter)
{
if (!metaReader.IsAssembly)
{
return;
}
var assembly = metaReader.GetAssemblyDefinition();
xmlWriter.WriteStartElement("File");
xmlWriter.WriteAttributeString("AssemblyName", metaReader.GetString(assembly.Name));
xmlWriter.WriteAttributeString("Version", assembly.Version.ToString(4));
var culture = metaReader.GetString(assembly.Culture);
xmlWriter.WriteAttributeString("Culture", string.IsNullOrEmpty(culture) ? "neutral" : culture);
var publicKey = metaReader.GetBlobBytes(assembly.PublicKey);
var publicKeyToken = PublicKeyTokenCalculator.CalculatePublicKeyToken(publicKey);
var publicKeyTokenStr = BitConverter.ToString(publicKeyToken).Replace("-", string.Empty).ToLowerInvariant();
xmlWriter.WriteAttributeString("PublicKeyToken", publicKeyTokenStr);
xmlWriter.WriteAttributeString("InGac", "false");
xmlWriter.WriteAttributeString("ProcessorArchitecture", "MSIL");
xmlWriter.WriteEndElement();
}
private void ReadAssemblyDefinition()
{
var definition = reader.GetAssemblyDefinition();
assemblyName = reader.GetString(definition.Name);
publicKey = definition.PublicKey.IsNil ? null : reader.GetBlobBytes(definition.PublicKey);
}
public static bool IsManaged(string file)
{
// Only files named *.dll and *.exe are considered as possible assemblies
if (!Path.HasExtension(file) || (Path.GetExtension(file) != ".dll" && Path.GetExtension(file) != ".exe"))
{
return(false);
}
try
{
using (FileStream moduleStream = File.OpenRead(file))
using (var module = new PEReader(moduleStream))
{
if (module.HasMetadata)
{
MetadataReader moduleMetadataReader = module.GetMetadataReader();
if (moduleMetadataReader.IsAssembly)
{
string culture = moduleMetadataReader.GetString(moduleMetadataReader.GetAssemblyDefinition().Culture);
if (culture == "" || culture.Equals("neutral", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
}
}
}
}
catch (BadImageFormatException)
{
}
return(false);
}
public EcmaModule GetModuleFromPath(string filePath)
{
// This is called once for every assembly that should be verified, so linear search is acceptable.
foreach (KeyValuePair <EcmaModule, ModuleData> entry in _moduleData)
{
EcmaModule curModule = entry.Key;
ModuleData curData = entry.Value;
if (curData.Path == filePath)
{
return(curModule);
}
}
PEReader peReader = new PEReader(File.OpenRead(filePath));
EcmaModule module = EcmaModule.Create(this, peReader);
MetadataReader metadataReader = module.MetadataReader;
string simpleName = metadataReader.GetString(metadataReader.GetAssemblyDefinition().Name);
if (_modules.ContainsKey(simpleName))
{
throw new CommandLineException("Module with same simple name already exists " + filePath);
}
_modules.Add(simpleName, module);
ModuleData moduleData = new ModuleData()
{
Path = filePath
};
_moduleData.Add(module, moduleData);
return(module);
}
private EcmaModule CreateModuleForSimpleName(string simpleName)
{
string filePath;
if (!InputFilePaths.TryGetValue(simpleName, out filePath))
{
if (!ReferenceFilePaths.TryGetValue(simpleName, out filePath))
{
throw new CommandLineException("Assembly not found: " + simpleName);
}
}
PEReader peReader = new PEReader(File.OpenRead(filePath));
EcmaModule module = EcmaModule.Create(this, peReader);
MetadataReader metadataReader = module.MetadataReader;
string actualSimpleName = metadataReader.GetString(metadataReader.GetAssemblyDefinition().Name);
if (!actualSimpleName.Equals(simpleName, StringComparison.OrdinalIgnoreCase))
{
throw new CommandLineException("Assembly name does not match filename " + filePath);
}
_modules.Add(simpleName, module);
ModuleData moduleData = new ModuleData()
{
Path = filePath
};
_moduleData.Add(module, moduleData);
return(module);
}
public static AssemblyInfo GetAssemblyInfo(string path)
{
try
{
using (PEReader peReader = new PEReader(new FileStream(path, FileMode.Open, FileAccess.Read)))
{
if (peReader.HasMetadata)
{
MetadataReader contractReader = peReader.GetMetadataReader();
AssemblyDefinition assembly = contractReader.GetAssemblyDefinition();
var name = contractReader.GetString(assembly.Name);
var version = assembly.Version;
var references = GetAssemblyReferences(contractReader);
var moduleReferences = GetModuleReferences(contractReader);
return(new AssemblyInfo(path, name, version, references, moduleReferences));
}
}
}
catch (BadImageFormatException)
{
//not a PE
}
return(null);
}
/// <summary>
/// Load an assembly from its MetadataReader. If reader is null, create a fake assembly.
/// </summary>
private MrAssembly LoadFromReader(MetadataReader reader, string name, string path, bool implicitLoad)
{
if (!_loading && !implicitLoad)
{
throw new Exception("Once FinishLoading() has been called, no more assemblies can be loaded");
}
MrAssembly newAssembly;
if (reader == null)
{
newAssembly = MrAssembly.CreateFakeAssembly(name, this);
}
else
{
Debug.Assert(name == reader.GetString(reader.GetAssemblyDefinition().Name) || name == "mscorlib");
// See if the assembly was already explicitly loaded
if (_loadedAssemblies.TryGetValue(name, out var loadedAssembly))
{
return(loadedAssembly);
}
// Or it might have been implicitly loaded
if (_implicitAssemblies.TryGetValue(name, out loadedAssembly))
{
if (implicitLoad)
{
return(loadedAssembly);
}
// This assembly was implicitly loaded, now it's being explicitly loaded,
// so move it from implicit to explicit.
_loadedAssemblies[name] = loadedAssembly;
_implicitAssemblies.Remove(name);
return(loadedAssembly);
}
// Prevent stack overflow by making this assembly exist before creating it
// (which might trigger a cycle of assembly references)
if (implicitLoad)
{
_implicitAssemblies[name] = null;
}
newAssembly = MrAssembly.Create(reader, path, this);
}
// Save the assembly
if (implicitLoad)
{
_implicitAssemblies[name] = newAssembly;
}
else
{
_loadedAssemblies[name] = newAssembly;
}
return(newAssembly);
}
internal MetadataModule(ICompilation compilation, Metadata.PEFile peFile, TypeSystemOptions options)
{
this.Compilation = compilation;
this.PEFile = peFile;
this.metadata = peFile.Metadata;
this.options = options;
this.TypeProvider = new TypeProvider(this);
// assembly metadata
if (metadata.IsAssembly)
{
var asmdef = metadata.GetAssemblyDefinition();
this.AssemblyName = metadata.GetString(asmdef.Name);
this.FullAssemblyName = metadata.GetFullAssemblyName();
}
else
{
var moddef = metadata.GetModuleDefinition();
this.AssemblyName = metadata.GetString(moddef.Name);
this.FullAssemblyName = this.AssemblyName;
}
this.rootNamespace = new MetadataNamespace(this, null, string.Empty, metadata.GetNamespaceDefinitionRoot());
if (!options.HasFlag(TypeSystemOptions.Uncached))
{
// create arrays for resolved entities, indexed by row index
this.typeDefs = new MetadataTypeDefinition[metadata.TypeDefinitions.Count + 1];
this.fieldDefs = new MetadataField[metadata.FieldDefinitions.Count + 1];
this.methodDefs = new MetadataMethod[metadata.MethodDefinitions.Count + 1];
this.propertyDefs = new MetadataProperty[metadata.PropertyDefinitions.Count + 1];
this.eventDefs = new MetadataEvent[metadata.EventDefinitions.Count + 1];
}
}
static HashAlgorithm GetHashAlgorithm(this MetadataReader reader)
{
switch (reader.GetAssemblyDefinition().HashAlgorithm)
{
case AssemblyHashAlgorithm.None:
// only for multi-module assemblies?
return(SHA1.Create());
case AssemblyHashAlgorithm.MD5:
return(MD5.Create());
case AssemblyHashAlgorithm.Sha1:
return(SHA1.Create());
case AssemblyHashAlgorithm.Sha256:
return(SHA256.Create());
case AssemblyHashAlgorithm.Sha384:
return(SHA384.Create());
case AssemblyHashAlgorithm.Sha512:
return(SHA512.Create());
default:
return(SHA1.Create()); // default?
}
}
private static Version GetAssemblyVersion(string sourcePath)
{
using (var assemblyStream = new FileStream(sourcePath, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read))
{
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);
}
}
private static PluginInfo ReadCore(string dllFile, MetadataReader reader)
{
var pluginController = reader.TypeDefinitions.Select(x => (TypeDefinition?)reader.GetTypeDefinition(x))
.FirstOrDefault(x => GetInterfaceImplementations(reader, (TypeDefinition)x).Any(y => y.Name == "IPluginController" && y.Namespace == "WpfPluginSample.PluginFramework"));
if (pluginController == null)
{
return(null);
}
var assembly = reader.GetAssemblyDefinition();
var customAttributes = assembly.GetCustomAttributes().Select(reader.GetCustomAttribute).Select(x =>
{
var ctor = reader.GetMemberReference((MemberReferenceHandle)x.Constructor);
var attrType = reader.GetTypeReference((TypeReferenceHandle)ctor.Parent);
return(new
{
Name = attrType.Name.ToString(reader),
Value = string.Join(";", x.GetParameterValues(reader))
});
}).ToArray();
var pluginControllerName = string.Join(".", new[]
{
pluginController.Value.Namespace.ToString(reader),
pluginController.Value.Name.ToString(reader)
}.Where(x => !string.IsNullOrEmpty(x)));
return(new PluginInfo(dllFile, pluginControllerName,
customAttributes.FirstOrDefault(x => x.Name == "AssemblyProductAttribute")?.Value,
assembly.Version.ToString(),
customAttributes.FirstOrDefault(x => x.Name == "AssemblyCompanyAttribute")?.Value,
customAttributes.FirstOrDefault(x => x.Name == "AssemblyCopyrightAttribute")?.Value));
}
public DiscoveredAssembly(string path, MetadataReader reader)
{
var definition = reader.GetAssemblyDefinition();
this.Path = path;
this.Name = reader.GetString(definition.Name);
this.ReferencedAssemblies = reader.AssemblyReferences
.Select(r => new { Token = reader.GetToken(r), AssemblyReference = reader.GetAssemblyReference(r) })
.Select(tr => DiscoveredAssembly.FromReference(tr.Token, reader.GetString(tr.AssemblyReference.Name)));
this.DefinedTypes = reader.TypeDefinitions
.Select(t => DiscoveredType.FromDefinedType(reader, t));
this.ReferencedTypes = reader.TypeReferences
.Select(r => new { Token = reader.GetToken(r), TypeReference = reader.GetTypeReference(r) })
.Select(tr =>
DiscoveredType.FromReferenceType(
tr.Token,
reader.GetString(tr.TypeReference.Name),
reader.GetString(tr.TypeReference.Namespace)));
var allTypes = this.DefinedTypes.Union(this.ReferencedTypes);
var resolvedTypes = new List <DiscoveredType>();
foreach (var type in allTypes)
{
resolvedTypes.Add(type.Resolve(allTypes));
}
this.ResolvedTypes = resolvedTypes;
}
string GetResourceDesignerClass(MetadataReader reader)
{
// Looking for:
// [assembly: Android.Runtime.ResourceDesignerAttribute("MyApp.Resource", IsApplication=true)]
var assembly = reader.GetAssemblyDefinition();
foreach (var handle in assembly.GetCustomAttributes())
{
var attribute = reader.GetCustomAttribute(handle);
var fullName = reader.GetCustomAttributeFullName(attribute);
if (fullName == "Android.Runtime.ResourceDesignerAttribute")
{
var values = attribute.GetCustomAttributeArguments();
foreach (var arg in values.NamedArguments)
{
// application resource IDs are constants, cannot merge.
if (arg.Name == "IsApplication" && arg.Value is bool isApplication && isApplication)
{
return(null);
}
}
return((string)values.FixedArguments.First().Value);
}
}
return(null);
}
public static AssemblyIdentity TryGetAssemblyIdentity(string filePath)
{
try
{
using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
using (PEReader peReader = new PEReader(stream))
{
MetadataReader 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 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);
}
public AssemblyEntry(PEFile module)
{
this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset;
this.module = module;
this.metadata = module.Metadata;
this.assembly = metadata.GetAssemblyDefinition();
}
public string GetAssemblyVersion()
{
Version result = null;
using (var fileStream = new FileStream(this.DllPath, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read))
{
try
{
using (PEReader pereader = new PEReader(fileStream, PEStreamOptions.LeaveOpen))
{
if (pereader.HasMetadata)
{
MetadataReader reader = pereader.GetMetadataReader();
if (reader.IsAssembly)
{
result = reader.GetAssemblyDefinition().Version;
}
}
}
}
catch (BadImageFormatException)
{
throw new ArgumentException($"Assembly {this.DllPath} has incorrect format", nameof(this.DllPath));
}
}
return(result.ToString());
}
public Context(Extraction.Context cx, string assemblyPath, bool extractPdbs)
{
this.cx = cx;
this.assemblyPath = assemblyPath;
stream = File.OpenRead(assemblyPath);
peReader = new PEReader(stream, PEStreamOptions.PrefetchEntireImage);
mdReader = peReader.GetMetadataReader();
TypeSignatureDecoder = new Entities.TypeSignatureDecoder(this);
globalNamespace = new Lazy <Entities.Namespace>(() => Populate(new Entities.Namespace(this, GetId(""), null)));
systemNamespace = new Lazy <Entities.Namespace>(() => Populate(new Entities.Namespace(this, "System")));
genericHandleFactory = new CachedFunction <GenericContext, Handle, ILabelledEntity>(CreateGenericHandle);
namespaceFactory = new CachedFunction <StringHandle, Entities.Namespace>(n => CreateNamespace(mdReader.GetString(n)));
namespaceDefinitionFactory = new CachedFunction <NamespaceDefinitionHandle, Entities.Namespace>(CreateNamespace);
sourceFiles = new CachedFunction <PDB.ISourceFile, Entities.PdbSourceFile>(path => new Entities.PdbSourceFile(this, path));
folders = new CachedFunction <string, Entities.Folder>(path => new Entities.Folder(this, path));
sourceLocations = new CachedFunction <PDB.Location, Entities.PdbSourceLocation>(location => new Entities.PdbSourceLocation(this, location));
defaultGenericContext = new EmptyContext(this);
var def = mdReader.GetAssemblyDefinition();
AssemblyPrefix = GetId(def.Name) + "_" + def.Version.ToString() + "::";
if (extractPdbs)
{
pdb = PDB.PdbReader.Create(assemblyPath, peReader);
if (pdb != null)
{
cx.Extractor.Logger.Log(Util.Logging.Severity.Info, string.Format("Found PDB information for {0}", assemblyPath));
}
}
}
private EcmaModule AddModule(string filePath, string expectedSimpleName)
{
MemoryMappedViewAccessor mappedViewAccessor = null;
PdbSymbolReader pdbReader = null;
try
{
PEReader peReader = OpenPEFile(filePath, out mappedViewAccessor);
pdbReader = OpenAssociatedSymbolFile(filePath);
EcmaModule module = EcmaModule.Create(this, peReader, pdbReader);
MetadataReader metadataReader = module.MetadataReader;
string simpleName = metadataReader.GetString(metadataReader.GetAssemblyDefinition().Name);
if (expectedSimpleName != null && !simpleName.Equals(expectedSimpleName, StringComparison.OrdinalIgnoreCase))
{
throw new FileNotFoundException("Assembly name does not match filename " + filePath);
}
ModuleData moduleData = new ModuleData()
{
SimpleName = simpleName,
FilePath = filePath,
Module = module,
MappedViewAccessor = mappedViewAccessor
};
lock (this)
{
ModuleData actualModuleData = _simpleNameHashtable.AddOrGetExisting(moduleData);
if (actualModuleData != moduleData)
{
if (actualModuleData.FilePath != filePath)
{
throw new FileNotFoundException("Module with same simple name already exists " + filePath);
}
return(actualModuleData.Module);
}
mappedViewAccessor = null; // Ownership has been transfered
pdbReader = null; // Ownership has been transferred
_moduleHashtable.AddOrGetExisting(moduleData);
}
return(module);
}
finally
{
if (mappedViewAccessor != null)
{
mappedViewAccessor.Dispose();
}
if (pdbReader != null)
{
pdbReader.Dispose();
}
}
}
/// <summary>
/// Get the strong name of a reference assembly represented by the 'metadataReader'
/// </summary>
private 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);
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.
string 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 void ParseAssemblyDefinition(MetadataReader reader)
{
var assembly = reader.GetAssemblyDefinition();
Name = reader.GetString(assembly.Name);
Version = assembly.Version;
PublicKey = reader.GetBlobBytes(assembly.PublicKey).ToList();
}
private EcmaModule AddModule(string filePath, string expectedSimpleName, byte[] moduleDataBytes, bool useForBinding)
{
MemoryMappedViewAccessor mappedViewAccessor = null;
PdbSymbolReader pdbReader = null;
try
{
PEReader peReader = OpenPEFile(filePath, moduleDataBytes, out mappedViewAccessor);
pdbReader = OpenAssociatedSymbolFile(filePath, peReader);
EcmaModule module = EcmaModule.Create(this, peReader, containingAssembly: null, pdbReader);
MetadataReader metadataReader = module.MetadataReader;
string simpleName = metadataReader.GetString(metadataReader.GetAssemblyDefinition().Name);
ModuleData moduleData = new ModuleData()
{
SimpleName = simpleName,
FilePath = filePath,
Module = module,
MappedViewAccessor = mappedViewAccessor
};
lock (this)
{
if (useForBinding)
{
ModuleData actualModuleData = _simpleNameHashtable.AddOrGetExisting(moduleData);
if (actualModuleData != moduleData)
{
if (actualModuleData.FilePath != filePath)
{
throw new FileNotFoundException("Module with same simple name already exists " + filePath);
}
return(actualModuleData.Module);
}
}
mappedViewAccessor = null; // Ownership has been transfered
pdbReader = null; // Ownership has been transferred
_moduleHashtable.AddOrGetExisting(moduleData);
}
return(module);
}
finally
{
if (mappedViewAccessor != null)
{
mappedViewAccessor.Dispose();
}
if (pdbReader != null)
{
pdbReader.Dispose();
}
}
}
