/// <summary>
/// Add an assembly to the assembly cache
/// </summary>
/// <param name="asm">The assembly</param>
/// <returns>
/// <c>true</c> if <paramref name="asm" /> is cached, <c>false</c> if it's not
/// cached because some other assembly with the exact same full name has already been
/// cached or if <paramref name="asm" /> is <c>null</c>.
/// </returns>
public bool AddToCache(AssemblyDef asm)
{
if (_cache.ContainsKey(asm))
return false;
_cache[asm] = asm;
return true;
}
public static bool isForm(AssemblyDef asm)
{
bool result = false;
foreach (ModuleDef current in asm.Modules)
{
foreach (TypeDef current2 in current.Types)
{
foreach (TypeDef current3 in current2.NestedTypes)
{
foreach (MethodDef current4 in current3.Methods)
{
if (current4.Name == "InitializeComponent")
{
result = true;
}
}
}
foreach (MethodDef current5 in current2.Methods)
{
if (current5.Name == "InitializeComponent")
{
result = true;
}
}
}
}
return result;
}
string GetBaseDirectory(AssemblyDef asm, ModuleDef mod) {
if (string.IsNullOrEmpty(mod.Location))
return string.Empty;
try {
return Path.GetDirectoryName(mod.Location);
}
catch {
return string.Empty;
}
}
public override AssemblyDef DeobfuscateAssembly(AssemblyDef asmDef)
{
Ctx.Assembly = asmDef;
Ctx.OriginalMD = (Ctx.Assembly.ManifestModule as ModuleDefMD);
InitializePipelines();
Pipelines["preRoutines"].Process();
Pipelines["routines"].Process();
return Ctx.Assembly;
}
public AssemblyOptions(AssemblyDef asm) {
HashAlgorithm = asm.HashAlgorithm;
Version = asm.Version;
Attributes = asm.Attributes;
PublicKey = asm.PublicKey;
Name = asm.Name;
Culture = asm.Culture;
ClrVersion = Module.ClrVersion.DefaultVersion;
CustomAttributes.AddRange(asm.CustomAttributes);
DeclSecurities.AddRange(asm.DeclSecurities);
}
private void InjectSettings(AssemblyDef asm)
{
var ep = asm.ManifestModule.EntryPoint;
var settingsMethod = ep.DeclaringType.FindMethod(new UTF8String("InitializeSettings"));
if (settingsMethod == null)
throw new ComponentMissingException("Failed to locate InitializeSettings method in stub");
settingsMethod.Body.Instructions[0].Operand = _settings.Hostname;
settingsMethod.Body.Instructions[2].OpCode = OpCodes.Ldc_I4;
settingsMethod.Body.Instructions[2].Operand = _settings.Port;
settingsMethod.Body.Instructions[4].OpCode = OpCodes.Ldc_I4;
settingsMethod.Body.Instructions[4].Operand = _settings.ReconnectDelay*1000;
}
IEnumerable<string> ResolveCLRNamespaces(AssemblyDef assembly, string ns) {
foreach (var attr in assembly.CustomAttributes.FindAll("System.Windows.Markup.XmlnsDefinitionAttribute")) {
Debug.Assert(attr.ConstructorArguments.Count == 2);
var xmlNs = attr.ConstructorArguments[0].Value;
var clrNs = attr.ConstructorArguments[1].Value;
Debug.Assert(xmlNs is UTF8String && clrNs is UTF8String);
if ((UTF8String)xmlNs == ns)
yield return (UTF8String)clrNs;
}
}
public AssemblyDef CopyTo(AssemblyDef asm) {
asm.HashAlgorithm = HashAlgorithm;
asm.Version = Version;
asm.Attributes = Attributes;
asm.PublicKey = PublicKey;
asm.Name = Name ?? UTF8String.Empty;
asm.Culture = Culture;
asm.CustomAttributes.Clear();
asm.CustomAttributes.AddRange(CustomAttributes);
asm.DeclSecurities.Clear();
asm.DeclSecurities.AddRange(DeclSecurities);
return asm;
}
private static DeobfuscatorBase FetchSubversion1_9(AssemblyDef asmDef)
{
foreach (var type in asmDef.ManifestModule.Types)
{
if (type.Name.String.StartsWith("Lzma") && type.HasNestedTypes && type.NestedTypes.Count == 6)
{
// Weak 1.9L detection
return Activator.CreateInstance<Deobfuscator19L>();
}
}
return Activator.CreateInstance<Deobfuscator19R>();
}
public override DocumentTreeNodeFilterResult GetResult(AssemblyDef asm) {
var thisFlag = VisibleMembersFlags.AssemblyDef;
var visibleFlags = thisFlag | VisibleMembersFlags.ModuleDef |
VisibleMembersFlags.Namespace | VisibleMembersFlags.AnyTypeDef |
VisibleMembersFlags.FieldDef | VisibleMembersFlags.MethodDef |
VisibleMembersFlags.InstanceConstructor | VisibleMembersFlags.PropertyDef |
VisibleMembersFlags.EventDef | VisibleMembersFlags.AssemblyRef |
VisibleMembersFlags.BaseTypes | VisibleMembersFlags.DerivedTypes |
VisibleMembersFlags.ModuleRef | VisibleMembersFlags.ResourceList |
VisibleMembersFlags.MethodBody | VisibleMembersFlags.ParamDefs |
VisibleMembersFlags.ParamDef | VisibleMembersFlags.Locals |
VisibleMembersFlags.Local | VisibleMembersFlags.Resource |
VisibleMembersFlags.ResourceElement | VisibleMembersFlags.Other |
VisibleMembersFlags.Attributes;
return FilterFile(thisFlag, visibleFlags);
}
protected void WriteAssembly(AssemblyDef asm, IDecompilerOutput output, DecompilationContext ctx) {
DecompileInternal(asm, output, ctx);
output.WriteLine();
PrintEntryPoint(asm.ManifestModule, output);
var peImage = TryGetPEImage(asm.ManifestModule);
if (peImage != null) {
WriteCommentBegin(output, true);
uint ts = peImage.ImageNTHeaders.FileHeader.TimeDateStamp;
var date = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(ts);
var dateString = date.ToString(CultureInfo.CurrentUICulture.DateTimeFormat);
output.Write(string.Format(dnSpy_Decompiler_Resources.Decompile_Timestamp, ts, dateString), BoxedTextColor.Comment);
WriteCommentEnd(output, true);
output.WriteLine();
}
output.WriteLine();
}
IEnumerable<string> GetFiles(AssemblyDef asm, ModuleDef mod) {
var baseDir = GetBaseDirectory(asm, mod);
if (string.IsNullOrEmpty(baseDir))
yield break;
var baseDirs = new List<string>();
baseDirs.Add(baseDir);
//TODO: Add all privatePath dirs found in app.config
foreach (var bd in baseDirs) {
foreach (var dir in GetDirectories(baseDir)) {
var name = Path.GetFileName(dir);
if (!IsValidCulture(name))
continue;
yield return Path.Combine(dir, asm.Name + ".resources.dll");
yield return Path.Combine(dir, asm.Name, asm.Name + ".resources.dll");
}
}
}
public void Write(ISyntaxHighlightOutput output, ILanguage language, AssemblyDef asm, bool showToken, bool showAssemblyVersion, bool showAssemblyPublicKeyToken)
{
output.Write(asm.Name, IsExe(asm.ManifestModule) ? TextTokenKind.AssemblyExe : TextTokenKind.Assembly);
bool showAsmVer = showAssemblyVersion;
bool showPublicKeyToken = showAssemblyPublicKeyToken && !PublicKeyBase.IsNullOrEmpty2(asm.PublicKeyToken);
if (showAsmVer || showPublicKeyToken) {
output.WriteSpace();
output.Write("(", TextTokenKind.Operator);
bool needComma = false;
if (showAsmVer) {
if (needComma)
output.WriteCommaSpace();
needComma = true;
output.Write(asm.Version);
}
if (showPublicKeyToken) {
if (needComma)
output.WriteCommaSpace();
needComma = true;
var pkt = asm.PublicKeyToken;
if (PublicKeyBase.IsNullOrEmpty2(pkt))
output.Write("null", TextTokenKind.Keyword);
else
output.Write(pkt.ToString(), TextTokenKind.Number);
}
output.Write(")", TextTokenKind.Operator);
}
WriteToken(output, asm, showToken);
}
/// <summary>
/// Writes an assembly
/// </summary>
/// <param name="output">Output</param>
/// <param name="decompiler">Decompiler</param>
/// <param name="asm">Assembly</param>
/// <param name="showToken">true to write tokens</param>
/// <param name="showAssemblyVersion">true to write version</param>
/// <param name="showAssemblyPublicKeyToken">true to write public key token</param>
public void Write(ITextColorWriter output, IDecompiler decompiler, AssemblyDef asm, bool showToken, bool showAssemblyVersion, bool showAssemblyPublicKeyToken) {
output.Write(IsExe(asm.ManifestModule) ? BoxedTextColor.AssemblyExe : BoxedTextColor.Assembly, asm.Name);
bool showAsmVer = showAssemblyVersion;
bool showPublicKeyToken = showAssemblyPublicKeyToken && !PublicKeyBase.IsNullOrEmpty2(asm.PublicKeyToken);
if (showAsmVer || showPublicKeyToken) {
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
bool needComma = false;
if (showAsmVer) {
if (needComma)
output.WriteCommaSpace();
needComma = true;
output.Write(asm.Version);
}
if (showPublicKeyToken) {
if (needComma)
output.WriteCommaSpace();
needComma = true;
var pkt = asm.PublicKeyToken;
if (PublicKeyBase.IsNullOrEmpty2(pkt))
output.Write(BoxedTextColor.Keyword, "null");
else
output.Write(BoxedTextColor.Number, pkt.ToString());
}
output.Write(BoxedTextColor.Punctuation, ")");
}
WriteToken(output, asm, showToken);
}
/// <summary>
/// Returns <c>true</c> if <paramref name="asm"/> is inserted in <see cref="cachedAssemblies"/>
/// </summary>
/// <param name="asm">Assembly to check</param>
bool IsCached(AssemblyDef asm)
{
if (asm == null)
return false;
AssemblyDef cachedAsm;
return cachedAssemblies.TryGetValue(GetAssemblyNameKey(new AssemblyNameInfo(asm)), out cachedAsm) &&
cachedAsm == asm;
}
private IEnumerable <Tuple <AssemblyDef, ITypeDefOrRef> > GetAssemblyAndAnyFriends(AssemblyDef asm, CancellationToken ct)
{
if (asm == null)
{
yield break;
}
yield return(new Tuple <AssemblyDef, ITypeDefOrRef>(asm, analyzedType));
if (asm.HasCustomAttributes)
{
var attributes = asm.CustomAttributes
.Where(attr => attr.TypeFullName == "System.Runtime.CompilerServices.InternalsVisibleToAttribute");
var friendAssemblies = new HashSet <string>();
foreach (var attribute in attributes)
{
if (attribute.ConstructorArguments.Count == 0)
{
continue;
}
string assemblyName = attribute.ConstructorArguments[0].Value as UTF8String;
if (assemblyName == null)
{
continue;
}
assemblyName = assemblyName.Split(',')[0]; // strip off any public key info
friendAssemblies.Add(assemblyName);
}
if (friendAssemblies.Count > 0)
{
IEnumerable <LoadedAssembly> assemblies = MainWindow.Instance.CurrentAssemblyList.GetAssemblies().Where(assy => assy.AssemblyDefinition != null);
foreach (var assembly in assemblies)
{
ct.ThrowIfCancellationRequested();
if (friendAssemblies.Contains(assembly.AssemblyDefinition.Name))
{
var typeref = GetScopeTypeReferenceInAssembly(assembly.AssemblyDefinition);
if (typeref != null)
{
yield return(new Tuple <AssemblyDef, ITypeDefOrRef>(assembly.AssemblyDefinition, typeref));
}
}
}
}
}
}
public CompilerMetadataReference?Create(AssemblyDef asm) => CompilerMetadataReferenceCreator.Create(rawModuleBytesProvider, tempAssembly, asm.ManifestModule, nonNestedEditedTypeOrNull, makeEverythingPublic);
public SameAssemblyTreeViewNodeFilter(ModuleDef allowedMod, ITreeViewNodeFilter filter)
: base(filter)
{
this.allowedAsm = allowedMod.Assembly;
this.allowedMod = allowedMod;
}
private IEnumerable <Tuple <AssemblyDef, ITypeDefOrRef> > GetReferencingAssemblies(AssemblyDef asm, CancellationToken ct)
{
if (asm == null)
{
yield break;
}
yield return(new Tuple <AssemblyDef, ITypeDefOrRef>(asm, this.analyzedType));
IEnumerable <LoadedAssembly> assemblies = MainWindow.Instance.CurrentAssemblyList.GetAssemblies().Where(assy => assy.AssemblyDefinition != null);
foreach (var assembly in assemblies)
{
ct.ThrowIfCancellationRequested();
bool found = false;
foreach (var reference in assembly.AssemblyDefinition.Modules.OfType <ModuleDefMD>().SelectMany(module => module.GetAssemblyRefs()))
{
if (AssemblyNameComparer.CompareAll.CompareTo(asm, reference) == 0)
{
found = true;
break;
}
}
if (found)
{
var typeref = GetScopeTypeReferenceInAssembly(assembly.AssemblyDefinition);
if (typeref != null)
{
yield return(new Tuple <AssemblyDef, ITypeDefOrRef>(assembly.AssemblyDefinition, typeref));
}
}
}
}
/// <inheritdoc/>
public bool AddToCache(AssemblyDef asm)
{
return(true);
}
/// <inheritdoc/>
public bool Remove(AssemblyDef asm)
{
return(false);
}
public void AddNsMap(string clrNs, AssemblyDef assembly, string prefix) => AddNsMap(Tuple.Create(assembly, clrNs), prefix);
public ImageReference GetImageReference(AssemblyDef assembly) => GetImageReference(assembly.ManifestModule?.Characteristics ?? Characteristics.Dll);
public static void Main(String?[]?args)
{
if (args is null || args.Length == 0)
{
Console.WriteLine("Invalid arguments");
return;
}
String?path = args[0];
if (path.IsNullOrWhiteSpace())
{
Console.WriteLine("Empty path provided");
return;
}
var file = new FileInfo(path);
if (!file.Exists)
{
Console.WriteLine("No file found");
return;
}
ModuleContext ctx = ModuleDef.CreateModuleContext();
AssemblyDef? asm;
try
{
Byte[]? b = File.ReadAllBytes(file.FullName);
asm = AssemblyDef.Load(b, ctx);
} catch
{
Console.WriteLine("Error loading assembly");
return;
}
if (asm is null)
{
Console.WriteLine("Error loading assembly");
return;
}
String?loc = Assembly.GetExecutingAssembly().Location;
if (!loc.IsNullOrWhiteSpace())
{
var f = new FileInfo(loc);
LoadAssemblies(f.Directory.CreateSubdirectory("Extensions"));
}
for (Int32 i = 1; i < args.Length; ++i)
{
LoadAssemblies(new DirectoryInfo(args[i]));
}
if (PatchEntry.PatchAssembly(asm, ctx, new Logger()))
{
Console.WriteLine("Patch success, saving");
var opt = new ModuleWriterOptions(asm.ManifestModule);
asm.Write(path, opt);
for (Int32 i = 0; i < asm.Modules.Count; ++i)
{
ModuleDef?mod = asm.Modules[i];
if (mod.IsManifestModule)
{
continue;
}
var subOpt = new ModuleWriterOptions(mod);
mod.Write(path + mod.FullName + ".netmodule", subOpt);
}
}
else
{
Console.WriteLine("Patch failed, will not save");
}
}
bool IAssemblyResolver.AddToCache(AssemblyDef asm)
{
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyReflectionNode"/> class.
/// </summary>
/// <param name="assemblyDefinition">The assembly definition.</param>
public AssemblyReflectionNode(AssemblyDef assemblyDefinition)
{
_assemblyDefinition = assemblyDefinition;
}
public EntryPointTreeViewNodeFilter(ModuleDef module) {
this.module = module;
this.assembly = module.Assembly;
}
public virtual DocumentTreeNodeFilterResult GetResult(AssemblyDef asm) => new DocumentTreeNodeFilterResult(FilterType.Hide, false);
bool IAssemblyResolver.Remove(AssemblyDef asm)
{
return(false);
}
static void Inspection(ConfuserContext context)
{
context.Logger.Info("Resolving dependencies...");
foreach (var dependency in context.Modules
.SelectMany(module => module.GetAssemblyRefs().Select(asmRef => Tuple.Create(asmRef, module))))
{
try {
AssemblyDef assembly = context.Resolver.ResolveThrow(dependency.Item1, dependency.Item2);
}
catch (AssemblyResolveException ex) {
context.Logger.ErrorException("Failed to resolve dependency of '" + dependency.Item2.Name + "'.", ex);
throw new ConfuserException(ex);
}
}
context.Logger.Debug("Checking Strong Name...");
foreach (ModuleDefMD module in context.Modules)
{
var snKey = context.Annotations.Get <StrongNameKey>(module, Marker.SNKey);
if (snKey == null && module.IsStrongNameSigned)
{
context.Logger.WarnFormat("[{0}] SN Key is not provided for a signed module, the output may not be working.", module.Name);
}
else if (snKey != null && !module.IsStrongNameSigned)
{
context.Logger.WarnFormat("[{0}] SN Key is provided for an unsigned module, the output may not be working.", module.Name);
}
else if (snKey != null && module.IsStrongNameSigned &&
!module.Assembly.PublicKey.Data.SequenceEqual(snKey.PublicKey))
{
context.Logger.WarnFormat("[{0}] Provided SN Key and signed module's public key do not match, the output may not be working.", module.Name);
}
}
var marker = context.Registry.GetService <IMarkerService>();
context.Logger.Debug("Creating global .cctors...");
foreach (ModuleDefMD module in context.Modules)
{
TypeDef modType = module.GlobalType;
if (modType == null)
{
modType = new TypeDefUser("", "<Module>", null);
modType.Attributes = TypeAttributes.AnsiClass;
module.Types.Add(modType);
marker.Mark(modType, null);
}
MethodDef cctor = modType.FindOrCreateStaticConstructor();
if (!marker.IsMarked(cctor))
{
marker.Mark(cctor, null);
}
}
context.Logger.Debug("Watermarking...");
foreach (ModuleDefMD module in context.Modules)
{
TypeRef attrRef = module.CorLibTypes.GetTypeRef("System", "Attribute");
var attrType = new TypeDefUser("", "ConfusedByAttribute", attrRef);
module.Types.Add(attrType);
marker.Mark(attrType, null);
var ctor = new MethodDefUser(
".ctor",
MethodSig.CreateInstance(module.CorLibTypes.Void, module.CorLibTypes.String),
MethodImplAttributes.Managed,
MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
ctor.Body = new CilBody();
ctor.Body.MaxStack = 1;
ctor.Body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
ctor.Body.Instructions.Add(OpCodes.Call.ToInstruction(new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), attrRef)));
ctor.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
attrType.Methods.Add(ctor);
marker.Mark(ctor, null);
var attr = new CustomAttribute(ctor);
attr.ConstructorArguments.Add(new CAArgument(module.CorLibTypes.String, Version));
module.CustomAttributes.Add(attr);
}
}
void PopulateReferences(BamlDocument document)
{
var clrNs = new Dictionary <string, List <Tuple <AssemblyDef, string> > >();
assemblyRefs.Clear();
foreach (AssemblyInfoRecord rec in document.OfType <AssemblyInfoRecord>())
{
AssemblyDef assembly = context.Resolver.ResolveThrow(rec.AssemblyFullName, Module);
assemblyRefs.Add(rec.AssemblyId, assembly);
if (!context.Modules.Any(m => m.Assembly == assembly))
{
continue;
}
foreach (CustomAttribute attr in assembly.CustomAttributes.FindAll("System.Windows.Markup.XmlnsDefinitionAttribute"))
{
clrNs.AddListEntry(
(UTF8String)attr.ConstructorArguments[0].Value,
Tuple.Create(assembly, (string)(UTF8String)attr.ConstructorArguments[1].Value));
}
}
xmlnsCtx = new XmlNsContext(document, assemblyRefs);
typeRefs.Clear();
foreach (TypeInfoRecord rec in document.OfType <TypeInfoRecord>())
{
AssemblyDef assembly;
var asmId = (short)(rec.AssemblyId & 0xfff);
if (asmId == -1)
{
assembly = things.FrameworkAssembly;
}
else
{
assembly = assemblyRefs[(ushort)asmId];
}
AssemblyDef assemblyRef = Module.Assembly == assembly ? null : assembly;
TypeSig typeSig = TypeNameParser.ParseAsTypeSigReflectionThrow(Module, rec.TypeFullName, new DummyAssemblyRefFinder(assemblyRef));
typeRefs[rec.TypeId] = typeSig;
AddTypeSigReference(typeSig, new BAMLTypeReference(typeSig, rec));
}
attrRefs.Clear();
foreach (AttributeInfoRecord rec in document.OfType <AttributeInfoRecord>())
{
TypeSig declType;
if (typeRefs.TryGetValue(rec.OwnerTypeId, out declType))
{
TypeDef type = declType.ToBasicTypeDefOrRef().ResolveTypeDefThrow();
attrRefs[rec.AttributeId] = AnalyzeAttributeReference(type, rec);
}
else
{
Debug.Assert((short)rec.OwnerTypeId < 0);
TypeDef declTypeDef = things.Types((KnownTypes)(-(short)rec.OwnerTypeId));
attrRefs[rec.AttributeId] = AnalyzeAttributeReference(declTypeDef, rec);
}
}
strings.Clear();
foreach (StringInfoRecord rec in document.OfType <StringInfoRecord>())
{
strings[rec.StringId] = rec;
}
foreach (PIMappingRecord rec in document.OfType <PIMappingRecord>())
{
var asmId = (short)(rec.AssemblyId & 0xfff);
AssemblyDef assembly;
if (asmId == -1)
{
assembly = things.FrameworkAssembly;
}
else
{
assembly = assemblyRefs[(ushort)asmId];
}
Tuple <AssemblyDef, string> scope = Tuple.Create(assembly, rec.ClrNamespace);
clrNs.AddListEntry(rec.XmlNamespace, scope);
}
xmlns.Clear();
foreach (XmlnsPropertyRecord rec in document.OfType <XmlnsPropertyRecord>())
{
List <Tuple <AssemblyDef, string> > clrMap;
if (clrNs.TryGetValue(rec.XmlNamespace, out clrMap))
{
xmlns[rec.Prefix] = clrMap;
foreach (var scope in clrMap)
{
xmlnsCtx.AddNsMap(scope, rec.Prefix);
}
}
}
}
public void Run(AstNode compilationUnit)
{
// First determine all the namespaces that need to be imported:
compilationUnit.AcceptVisitor(new FindRequiredImports(this), null);
importedNamespaces.Add("System"); // always import System, even when not necessary
importedOrDeclaredNamespaces.Add("System");
if (context.Settings.UsingDeclarations)
{
// Now add using declarations for those namespaces:
foreach (string ns in GetNamespacesInReverseOrder())
{
// we go backwards (OrderByDescending) through the list of namespaces because we insert them backwards
// (always inserting at the start of the list)
string[] parts = ns.Split(namespaceSep);
AstType nsType = new SimpleType(parts[0]).WithAnnotation(TextTokenKind.NamespacePart);
for (int i = 1; i < parts.Length; i++)
{
nsType = new MemberType {
Target = nsType, MemberNameToken = Identifier.Create(parts[i]).WithAnnotation(TextTokenKind.NamespacePart)
}.WithAnnotation(TextTokenKind.NamespacePart);
}
compilationUnit.InsertChildAfter(null, new UsingDeclaration {
Import = nsType
}, SyntaxTree.MemberRole);
}
}
if (!context.Settings.FullyQualifyAmbiguousTypeNames && !context.Settings.FullyQualifyAllTypes)
{
return;
}
if (context.CurrentModule != null)
{
if (lastCheckedModule != context.CurrentModule)
{
typesWithNamespace_currentModule.Clear();
BuildAmbiguousTypeNamesTable(typesWithNamespace_currentModule, context.CurrentModule.Types, true);
}
FindAmbiguousTypeNames(typesWithNamespace_currentModule, true);
if (lastCheckedModule != context.CurrentModule)
{
var asmDict = new Dictionary <AssemblyDef, List <AssemblyDef> >(AssemblyEqualityComparer.Instance);
lastCheckedModule = context.CurrentModule;
foreach (var r in context.CurrentModule.GetAssemblyRefs())
{
AssemblyDef d = context.CurrentModule.Context.AssemblyResolver.Resolve(r, context.CurrentModule);
if (d == null)
{
continue;
}
List <AssemblyDef> list;
if (!asmDict.TryGetValue(d, out list))
{
asmDict.Add(d, list = new List <AssemblyDef>());
}
list.Add(d);
}
typesWithNamespace_allAsms_list.Clear();
foreach (var list in asmDict.Values)
{
var dict = new Dictionary <string, List <TypeDef> >(StringComparer.Ordinal);
BuildAmbiguousTypeNamesTable(dict, GetTypes(list), false);
typesWithNamespace_allAsms_list.Add(dict);
}
}
foreach (var dict in typesWithNamespace_allAsms_list)
{
FindAmbiguousTypeNames(dict, false);
}
}
// verify that the SimpleTypes refer to the correct type (no ambiguities)
compilationUnit.AcceptVisitor(new FullyQualifyAmbiguousTypeNamesVisitor(this), null);
}
public override void Decompile(AssemblyDef asm, IDecompilerOutput output, DecompilationContext ctx) => WriteError(output);
public DummyAssemblyRefFinder(AssemblyDef assemblyDef)
{
this.assemblyDef = assemblyDef;
}
public CompilerMetadataReference?Create(AssemblyDef asm) => CompilerMetadataReferenceCreator.Create(rawModuleBytesProvider, asm.ManifestModule, makeEverythingPublic);
public bool Remove(AssemblyDef asm) {
IAssemblyResolver ar = DnSpyFileList.AssemblyResolver;
return ar.Remove(asm);
}
public void InitialiseAssemblyDefFileUsedForTests()
{
string dir = System.AppDomain.CurrentDomain.BaseDirectory;
_assemblyDef = AssemblyDef.Create(System.IO.Path.Combine(dir, TestFile));
}
void DecompileInternal(AssemblyDef asm, IDecompilerOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, asm.ManifestModule.Location);
if (asm.IsContentTypeWindowsRuntime)
this.WriteCommentLine(output, asm.Name + " [WinRT]");
else
this.WriteCommentLine(output, asm.FullName);
}
public virtual FileTreeNodeFilterResult GetResult(AssemblyDef asm)
{
return(new FileTreeNodeFilterResult(FilterType.Hide, false));
}
public virtual DocumentTreeNodeFilterResult GetResult(AssemblyDef asm) => new DocumentTreeNodeFilterResult();
AssemblyDef FindClosestAssembly(AssemblyNameInfo assembly, AssemblyDef closest, IEnumerable<string> paths, ModuleContext moduleContext)
{
if (paths == null)
return closest;
var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
foreach (var path in paths) {
ModuleDefMD mod = null;
try {
mod = ModuleDefMD.Load(path, moduleContext);
var asm = mod.Assembly;
if (asm != null && asmComparer.CompareClosest(assembly, new AssemblyNameInfo(closest), new AssemblyNameInfo(asm)) == 1) {
if (!IsCached(closest) && closest != null && closest.ManifestModule != null)
closest.ManifestModule.Dispose();
closest = asm;
mod = null;
}
}
catch {
}
finally {
if (mod != null)
mod.Dispose();
}
}
return closest;
}
public virtual AssemblyDef DeobfuscateAssembly(AssemblyDef asmDef)
{
return null;
}
public ImageReference GetImageReference(AssemblyDef assembly) {
var mod = assembly.ManifestModule;
return GetImageReference(mod != null ? mod.Characteristics : Characteristics.Dll);
}
bool IAssemblyResolver.AddToCache(AssemblyDef asm)
{
return false;
}
IEnumerable <AnalyzerTreeNodeData> FindReferencesInModule(IEnumerable <ModuleDef> modules, ITypeDefOrRef tr, CancellationToken ct)
{
var checkedAsms = new HashSet <AssemblyDef>();
foreach (var module in modules)
{
if ((usage & AttributeTargets.Assembly) != 0)
{
AssemblyDef asm = module.Assembly;
if (asm != null && !checkedAsms.Contains(asm) && asm.HasCustomAttributes)
{
checkedAsms.Add(asm);
foreach (var attribute in asm.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, tr))
{
yield return(new AssemblyNode(asm)
{
Context = Context
});
break;
}
}
}
}
ct.ThrowIfCancellationRequested();
if ((usage & AttributeTargets.Module) != 0)
{
if (module.HasCustomAttributes)
{
foreach (var attribute in module.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, tr))
{
yield return(new ModuleNode(module)
{
Context = Context
});
break;
}
}
}
}
ct.ThrowIfCancellationRequested();
foreach (TypeDef type in TreeTraversal.PreOrder(module.Types, t => t.NestedTypes))
{
ct.ThrowIfCancellationRequested();
foreach (var result in FindReferencesWithinInType(type, tr))
{
ct.ThrowIfCancellationRequested();
yield return(result);
}
}
}
}
public AssemblyNode(AssemblyDef analyzedAssembly) => this.analyzedAssembly = analyzedAssembly;
public string GetPrefix(string clrNs, AssemblyDef assembly)
{
string prefix;
if (!xmlNsMap.TryGetValue(Tuple.Create(assembly, clrNs), out prefix)) {
prefix = "_" + x++;
ushort assemblyId = assemblyRefs[assembly];
doc.Insert(rootIndex, new XmlnsPropertyRecord {
AssemblyIds = new[] { assemblyId },
Prefix = prefix,
XmlNamespace = "clr-namespace:" + clrNs
});
doc.Insert(rootIndex - 1, new PIMappingRecord {
AssemblyId = assemblyId,
ClrNamespace = clrNs,
XmlNamespace = "clr-namespace:" + clrNs
});
rootIndex++;
}
return prefix;
}
public virtual DocumentTreeNodeFilterResult GetResult(AssemblyDef asm) => new DocumentTreeNodeFilterResult();
public bool AddToCache(AssemblyDef asm) {
IAssemblyResolver ar = DnSpyFileList.AssemblyResolver;
return ar.AddToCache(asm);
}
DocumentTabReferenceResult Create(AssemblyDef asm)
{
var node = documentTreeView.FindNode(asm);
return(node == null ? null : Create(node));
}
public virtual void Decompile(AssemblyDef asm, IDecompilerOutput output, DecompilationContext ctx) => DecompileInternal(asm, output, ctx);
/// <summary>
/// Utilises the information provided to create instances of specific Page classes.
/// </summary>
/// <param name="forItem">The item to create the Page for</param>
/// <param name="commentsXml">The comments file where the code comments can be obtained</param>
/// <param name="mapReference">The DocumentMap to use and to add to</param>
/// <returns>A new Page instance that can be displayed in the LiveDocumentor</returns>
public static Page Create(Entry entry, ICommentSource commentsXml)
{
TraceHelper.WriteLine("create page");
TraceHelper.Indent();
object forItem = entry.Item;
Page created = null;
if (forItem is AssemblyDef)
{
AssemblyDef ass = forItem as AssemblyDef;
TraceHelper.WriteLine("assemblydef ({0})", ass.Name);
created = new AssemblyPage(ass, commentsXml);
}
else if (forItem is MethodDef)
{
MethodDef method = forItem as MethodDef;
TraceHelper.WriteLine("method ({0}.{1}.{2})", method.Type.Namespace, method.Type.Name, method.Name);
created = new MethodPage(method, commentsXml);
}
else if (forItem is List <MethodDef> )
{
TraceHelper.WriteLine("methods page");
created = new TypeMethodsPage(forItem as List <MethodDef>, commentsXml);
}
else if (forItem is TypeDef)
{
TypeDef typeDef = forItem as TypeDef;
TraceHelper.WriteLine("typedef ({0}.{1})", typeDef.Namespace, typeDef.Name);
if (typeDef.InheritsFrom != null && typeDef.InheritsFrom.GetFullyQualifiedName() == "System.Enum")
{
created = new EnumerationPage(forItem as TypeDef, commentsXml);
}
else if (typeDef.IsDelegate)
{
created = new DelegatePage(forItem as TypeDef, commentsXml);
}
else
{
created = new TypePage(forItem as TypeDef, commentsXml);
}
}
else if (forItem is KeyValuePair <string, List <TypeDef> > )
{
TraceHelper.WriteLine("namespace {0}", ((KeyValuePair <string, List <TypeDef> >)forItem).Key);
created = new NamespacePage((KeyValuePair <string, List <TypeDef> >)forItem, commentsXml);
}
else if (forItem is List <FieldDef> )
{
TraceHelper.WriteLine("fields page");
created = new TypeFieldsPage(forItem as List <FieldDef>, commentsXml);
}
else if (forItem is FieldDef)
{
FieldDef field = forItem as FieldDef;
TraceHelper.WriteLine("field ({0}.{1}.{2})", field.Type.Namespace, field.Type.Name, field.Name);
created = new FieldPage(field, commentsXml);
}
else if (forItem is List <PropertyDef> )
{
TraceHelper.WriteLine("properties page");
created = new TypePropertiesPage(forItem as List <PropertyDef>, commentsXml);
}
else if (forItem is PropertyDef)
{
PropertyDef property = forItem as PropertyDef;
TraceHelper.WriteLine("property ({0}.{1}.{2})", property.OwningType.Namespace, property.OwningType.Name, property.Name);
created = new PropertyPage(property, commentsXml);
}
else if (forItem is List <EventDef> )
{
TraceHelper.WriteLine("events page");
created = new TypeEventsPage(forItem as List <EventDef>, commentsXml);
}
else if (forItem is EventDef)
{
EventDef ev = forItem as EventDef;
TraceHelper.WriteLine("event ({0}.{1}.{2})", ev.Type.Namespace, ev.Type.Name, ev.Name);
created = new EventPage(ev, commentsXml);
}
else if (forItem is TheBoxSoftware.Documentation.EntryTypes)
{
TheBoxSoftware.Documentation.EntryTypes type = (Documentation.EntryTypes)forItem;
switch (type)
{
case Documentation.EntryTypes.NamespaceContainer:
created = new NamespaceContainerPage(entry);
break;
}
}
else
{
created = new Page(forItem.ToString());
}
TraceHelper.Unindent();
return(created);
}
public DummyAssemblyRefFinder(AssemblyDef assemblyDef)
{
this.assemblyDef = assemblyDef;
}
public virtual void Decompile(AssemblyDef asm, IDecompilerOutput output, DecompilationContext ctx) => DecompileInternal(asm, output, ctx);
public AssemblyTreeNode FindAssemblyNode(AssemblyDef asm)
{
if (asm == null)
return null;
App.Current.Dispatcher.VerifyAccess();
foreach (AssemblyTreeNode node in this.Children) {
if (node.LoadedAssembly.IsLoaded && node.LoadedAssembly.AssemblyDefinition == asm)
return node;
}
return null;
}
static (string framework, string version, string profile) TryGetTargetFrameworkAttribute(AssemblyDef asm)
{
var ca = asm?.CustomAttributes.Find("System.Runtime.Versioning.TargetFrameworkAttribute");
if (ca == null)
{
return(default);
/// <summary>
/// Reads a module
/// </summary>
/// <param name="fileRid">File rid</param>
/// <param name="owner">The assembly owning the module we should read</param>
/// <returns>A new <see cref="ModuleDefMD"/> instance or <c>null</c> if <paramref name="fileRid"/>
/// is invalid or if it's not a .NET module.</returns>
internal ModuleDefMD ReadModule(uint fileRid, AssemblyDef owner)
{
var fileDef = ResolveFile(fileRid);
if (fileDef == null)
return null;
if (!fileDef.ContainsMetaData)
return null;
var fileName = GetValidFilename(GetBaseDirectoryOfImage(), UTF8String.ToSystemString(fileDef.Name));
if (fileName == null)
return null;
ModuleDefMD module;
try {
module = ModuleDefMD.Load(fileName);
}
catch {
module = null;
}
if (module != null) {
// share context
module.context = context;
var asm = module.Assembly;
if (asm != null && asm != owner)
asm.Modules.Remove(module);
}
return module;
}
public ImageReference GetImageReference(AssemblyDef assembly)
{
var mod = assembly.ManifestModule;
return(GetImageReference(mod != null ? mod.Characteristics : Characteristics.Dll));
}
bool IAssemblyResolver.Remove(AssemblyDef asm)
{
return false;
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInAssembly(IEnumerable <ModuleDef> modules, ITypeDefOrRef tr, CancellationToken ct)
{
foreach (var module in modules)
{
//since we do not display modules as separate entities, coalesce the assembly and module searches
bool foundInAssyOrModule = false;
if ((usage & AttributeTargets.Assembly) != 0)
{
AssemblyDef asm = module.Assembly;
if (asm != null && asm.HasCustomAttributes)
{
foreach (var attribute in asm.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, tr))
{
foundInAssyOrModule = true;
break;
}
}
}
}
if (!foundInAssyOrModule)
{
ct.ThrowIfCancellationRequested();
//search module
if ((usage & AttributeTargets.Module) != 0)
{
if (module.HasCustomAttributes)
{
foreach (var attribute in module.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, tr))
{
foundInAssyOrModule = true;
break;
}
}
}
}
}
if (foundInAssyOrModule)
{
yield return(new AnalyzedAssemblyTreeNode(module));
}
ct.ThrowIfCancellationRequested();
foreach (TypeDef type in TreeTraversal.PreOrder(module.Types, t => t.NestedTypes).OrderBy(t => t.FullName))
{
ct.ThrowIfCancellationRequested();
foreach (var result in FindReferencesWithinInType(type, tr))
{
ct.ThrowIfCancellationRequested();
yield return(result);
}
}
}
}
