重构Rename

2025-05-03 23:23:16 +08:00 · 2025-05-03 23:23:16 +08:00 · 0686c0e6da
parent fafc7d11a9
commit 0686c0e6da
15 changed files with 125 additions and 111 deletions
--- a/Editor/CleanUpInstructionPass.cs
+++ b/Editor/CleanUpInstructionPass.cs
@ -21,9 +21,9 @@ namespace Obfuz

        public override void Process(ObfuscatorContext ctx)
        {
-            foreach (var ass in ctx.assemblies)
+            foreach (ModuleDef mod in ctx.toObfuscatedModules)
            {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                {
                    foreach (MethodDef method in type.Methods)
                    {
--- a/Editor/MethodBodyObfuscationPassBase.cs
+++ b/Editor/MethodBodyObfuscationPassBase.cs
@ -11,10 +11,10 @@ namespace Obfuz

        public override void Process(ObfuscatorContext ctx)
        {
-            foreach (var ass in ctx.assemblies)
+            foreach (ModuleDef mod in ctx.toObfuscatedModules)
            {
                // ToArray to avoid modify list exception
-                foreach (TypeDef type in ass.module.GetTypes().ToArray())
+                foreach (TypeDef type in mod.GetTypes().ToArray())
                {
                    if (type.Name.StartsWith("$Obfuz$"))
                    {
--- a/Editor/Obfuscator.cs
+++ b/Editor/Obfuscator.cs
@ -16,11 +16,10 @@ namespace Obfuz
        private readonly string _obfuscatedAssemblyOutputDir;
        private readonly AssemblyCache _assemblyCache;

-        private readonly List<ObfuzAssemblyInfo> _obfuzAssemblies = new List<ObfuzAssemblyInfo>();
-
-
        private readonly List<string> _toObfuscatedAssemblyNames;
        private readonly List<string> _notObfuscatedAssemblyNamesReferencingObfuscated;
+        private readonly List<ModuleDef> _toObfuscatedModules = new List<ModuleDef>();
+        private readonly List<ModuleDef> _obfuscatedAndNotObfuscatedModules = new List<ModuleDef>();

        private readonly ObfuzPipeline _pipeline = new ObfuzPipeline();

@ -63,7 +62,8 @@ namespace Obfuz
            _ctx = new ObfuscatorContext
            {
                assemblyCache = _assemblyCache,
-                assemblies = _obfuzAssemblies,
+                toObfuscatedModules = _toObfuscatedModules,
+                obfuscatedAndNotObfuscatedModules = _obfuscatedAndNotObfuscatedModules,
                toObfuscatedAssemblyNames = _toObfuscatedAssemblyNames,
                notObfuscatedAssemblyNamesReferencingObfuscated = _notObfuscatedAssemblyNamesReferencingObfuscated,
                obfuscatedAssemblyOutputDir = _obfuscatedAssemblyOutputDir,
@ -73,7 +73,7 @@ namespace Obfuz

        private void LoadAssemblies()
        {
-            foreach (string assName in _toObfuscatedAssemblyNames)
+            foreach (string assName in _toObfuscatedAssemblyNames.Concat(_notObfuscatedAssemblyNamesReferencingObfuscated))
            {
                ModuleDefMD mod = _assemblyCache.TryLoadModule(assName);
                if (mod == null)
@ -81,28 +81,11 @@ namespace Obfuz
                    Debug.Log($"assembly: {assName} not found! ignore.");
                    continue;
                }
-                var obfuzAsm = new ObfuzAssemblyInfo
+                if (_toObfuscatedAssemblyNames.Contains(assName))
                {
-                    name = assName,
-                    module = mod,
-                    referenceMeAssemblies = new List<ObfuzAssemblyInfo>(),
-                };
-                obfuzAsm.referenceMeAssemblies.Add(obfuzAsm);
-                _obfuzAssemblies.Add(obfuzAsm);
-            }
-            
-            var assByName = _obfuzAssemblies.ToDictionary(x => x.name);
-            foreach (var ass in _obfuzAssemblies)
-            {
-                foreach (var refAss in ass.module.GetAssemblyRefs())
-                {
-                    string refAssName = refAss.Name.ToString();
-                    if (assByName.TryGetValue(refAssName, out var refAssembly))
-                    {
-                        //UnityEngine.Debug.Log($"assembly:{ass.name} reference to {refAssName}");
-                        refAssembly.referenceMeAssemblies.Add(ass);
-                    }
+                    _toObfuscatedModules.Add(mod);
                }
+                _obfuscatedAndNotObfuscatedModules.Add(mod);
            }
        }

@ -117,11 +100,12 @@ namespace Obfuz
        {
            _pipeline.Stop(_ctx);

-            foreach (var ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _obfuscatedAndNotObfuscatedModules)
            {
-                string outputFile = $"{_obfuscatedAssemblyOutputDir}/{ass.module.Name}";
-                ass.module.Write(outputFile);
-                Debug.Log($"save module. oldName:{ass.name} newName:{ass.module.Name} output:{outputFile}");
+                string assNameWithExt = mod.Name;
+                string outputFile = $"{_obfuscatedAssemblyOutputDir}/{assNameWithExt}";
+                mod.Write(outputFile);
+                Debug.Log($"save module. name:{mod.Assembly.Name} output:{outputFile}");
            }
        }
    }
--- a/Editor/ObfuscatorContext.cs
+++ b/Editor/ObfuscatorContext.cs
@ -1,4 +1,5 @@
-using Obfuz.Rename;
+using dnlib.DotNet;
+using Obfuz.Rename;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@ -12,10 +13,10 @@ namespace Obfuz
    {
        public AssemblyCache assemblyCache;

-        public List<ObfuzAssemblyInfo> assemblies;
+        public List<ModuleDef> toObfuscatedModules;
+        public List<ModuleDef> obfuscatedAndNotObfuscatedModules;

        public List<string> toObfuscatedAssemblyNames;
-
        public List<string> notObfuscatedAssemblyNamesReferencingObfuscated;

        public string obfuscatedAssemblyOutputDir;
--- a/Editor/ObfuzAssemblyInfo.cs
+++ b/Editor/ObfuzAssemblyInfo.cs
@ -1,14 +0,0 @@
-using dnlib.DotNet;
-using System.Collections.Generic;
-
-namespace Obfuz
-{
-    public class ObfuzAssemblyInfo
-    {
-        public string name;
-
-        public ModuleDefMD module;
-
-        public List<ObfuzAssemblyInfo> referenceMeAssemblies;
-    }
-}
--- a/Editor/Rename/CacheRenamePolicy.cs
+++ b/Editor/Rename/CacheRenamePolicy.cs
@ -15,7 +15,7 @@ namespace Obfuz.Rename
            _underlyingPolicy = underlyingPolicy;
        }

-        public override bool NeedRename(ModuleDefMD mod)
+        public override bool NeedRename(ModuleDef mod)
        {
            if (!_computeCache.TryGetValue(mod, out var value))
            {
--- a/Editor/Rename/CombineRenamePolicy.cs
+++ b/Editor/Rename/CombineRenamePolicy.cs
@ -12,7 +12,7 @@ namespace Obfuz.Rename
            _policies = policies;
        }

-        public bool NeedRename(ModuleDefMD mod)
+        public bool NeedRename(ModuleDef mod)
        {
            return _policies.All(policy => policy.NeedRename(mod));
        }
--- a/Editor/Rename/INameMaker.cs
+++ b/Editor/Rename/INameMaker.cs
@ -4,7 +4,7 @@ namespace Obfuz.Rename
 {
    public interface INameMaker
    {
-        void AddPreservedName(ModuleDefMD mod, string name);
+        void AddPreservedName(ModuleDef mod, string name);
        
        void AddPreservedName(TypeDef typeDef, string name);

@ -20,7 +20,7 @@ namespace Obfuz.Rename

        void AddPreservedName(EventDef eventDef, string name);

-        string GetNewName(ModuleDefMD mod, string originalName);
+        string GetNewName(ModuleDef mod, string originalName);

        string GetNewName(TypeDef typeDef, string originalName);

--- a/Editor/Rename/IRenamePolicy.cs
+++ b/Editor/Rename/IRenamePolicy.cs
@ -4,7 +4,7 @@ namespace Obfuz.Rename
 {
    public interface IRenamePolicy
    {
-        bool NeedRename(ModuleDefMD mod);
+        bool NeedRename(ModuleDef mod);

        bool NeedRename(TypeDef typeDef);

--- a/Editor/Rename/NameMakerBase.cs
+++ b/Editor/Rename/NameMakerBase.cs
@ -26,7 +26,7 @@ namespace Obfuz.Rename
            return nameScope;
        }

-        public void AddPreservedName(ModuleDefMD mod, string name)
+        public void AddPreservedName(ModuleDef mod, string name)
        {
            GetNameScope(mod).AddPreservedName(name);
        }
@ -67,7 +67,7 @@ namespace Obfuz.Rename
        }


-        public string GetNewName(ModuleDefMD mod, string originalName)
+        public string GetNewName(ModuleDef mod, string originalName)
        {
            return GetDefaultNewName(this, originalName);
        }
--- a/Editor/Rename/ObfuscateRuleConfig.cs
+++ b/Editor/Rename/ObfuscateRuleConfig.cs
@ -11,7 +11,7 @@ using UnityEngine;
 namespace Obfuz
 {

-    public class ObfuscateRuleConfig : IRenamePolicy
+    public class ObfuscateRuleConfig : RenamePolicyBase
    {
        enum ObfuscationType
        {
@ -610,7 +610,7 @@ namespace Obfuz
            }
        }

-        public bool NeedRename(ModuleDefMD mod)
+        public override bool NeedRename(ModuleDef mod)
        {
            //string name = mod.Assembly.Name;
            //if (!_assemblyRuleSpecs.TryGetValue(name, out var assemblyRuleSpec))
@ -839,13 +839,13 @@ namespace Obfuz
            return cache;
        }

-        public bool NeedRename(TypeDef typeDef)
+        public override bool NeedRename(TypeDef typeDef)
        {
            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
            return cache.obfuscateName;
        }

-        public bool NeedRename(MethodDef methodDef)
+        public override bool NeedRename(MethodDef methodDef)
        {
            TypeDef typeDef = methodDef.DeclaringType;
            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
@ -856,28 +856,28 @@ namespace Obfuz
            return methodCache.obfuscateName;
        }

-        public bool NeedRename(FieldDef fieldDef)
+        public override bool NeedRename(FieldDef fieldDef)
        {
            TypeDef typeDef = fieldDef.DeclaringType;
            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
            return !cache.notObfuscatedFields.Contains(fieldDef);
        }

-        public bool NeedRename(PropertyDef propertyDef)
+        public override bool NeedRename(PropertyDef propertyDef)
        {
            TypeDef typeDef = propertyDef.DeclaringType;
            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
            return !cache.notObfuscatedProperties.Contains(propertyDef);
        }

-        public bool NeedRename(EventDef eventDef)
+        public override bool NeedRename(EventDef eventDef)
        {
            TypeDef typeDef = eventDef.DeclaringType;
            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
            return !cache.notObfuscatedEvents.Contains(eventDef);
        }

-        public bool NeedRename(ParamDef paramDef)
+        public override bool NeedRename(ParamDef paramDef)
        {
            MethodDef methodDef = paramDef.DeclaringMethod;
            TypeDef typeDef = methodDef.DeclaringType;
--- a/Editor/Rename/RenamePolicyBase.cs
+++ b/Editor/Rename/RenamePolicyBase.cs
@ -4,9 +4,9 @@ namespace Obfuz.Rename
 {
    public abstract class RenamePolicyBase : IRenamePolicy
    {
-        public virtual bool NeedRename(ModuleDefMD mod)
+        public virtual bool NeedRename(ModuleDef mod)
        {
-            return true;
+            return false;
        }

        public virtual bool NeedRename(TypeDef typeDef)
--- a/Editor/Rename/RenameRecordMap.cs
+++ b/Editor/Rename/RenameRecordMap.cs
@ -93,7 +93,7 @@ namespace Obfuz
        private readonly Dictionary<string, RenameMappingAssembly> _assemblies = new Dictionary<string, RenameMappingAssembly>();


-        private readonly Dictionary<ModuleDefMD, RenameRecord> _modRenames = new Dictionary<ModuleDefMD, RenameRecord>();
+        private readonly Dictionary<ModuleDef, RenameRecord> _modRenames = new Dictionary<ModuleDef, RenameRecord>();
        private readonly Dictionary<TypeDef, RenameRecord> _typeRenames = new Dictionary<TypeDef, RenameRecord>();
        private readonly Dictionary<MethodDef, RenameRecord> _methodRenames = new Dictionary<MethodDef, RenameRecord>();
        private readonly Dictionary<ParamDef, RenameRecord> _paramRenames = new Dictionary<ParamDef, RenameRecord>();
@ -108,12 +108,11 @@ namespace Obfuz
            _mappingFile = mappingFile;
        }

-        public void Init(List<ObfuzAssemblyInfo> assemblies, INameMaker nameMaker)
+        public void Init(List<ModuleDef> assemblies, INameMaker nameMaker)
        {
            LoadXmlMappingFile(_mappingFile);
-            foreach (var ObfuzAssemblyInfo in assemblies)
+            foreach (ModuleDef mod in assemblies)
            {
-                ModuleDefMD mod = ObfuzAssemblyInfo.module;
                string name = mod.Assembly.Name;
                nameMaker.AddPreservedName(mod, name);

@ -406,7 +405,7 @@ namespace Obfuz
            doc.AppendChild(root);
            foreach (var kvp in _modRenames)
            {
-                ModuleDefMD mod = kvp.Key;
+                ModuleDef mod = kvp.Key;
                RenameRecord record = kvp.Value;
                var assemblyNode = doc.CreateElement("assembly");
                assemblyNode.SetAttribute("name", mod.Assembly.Name);
@ -619,7 +618,7 @@ namespace Obfuz
            methodEle.AppendChild(paramNode);
        }

-        public void AddRename(ModuleDefMD mod, string newName)
+        public void AddRename(ModuleDef mod, string newName)
        {
            RenameRecord record = _modRenames[mod];
            record.status = RenameStatus.Renamed;
@ -680,7 +679,7 @@ namespace Obfuz
            record.newName = newName;
        }

-        public bool TryGetExistRenameMapping(ModuleDefMD mod, out string newName)
+        public bool TryGetExistRenameMapping(ModuleDef mod, out string newName)
        {
            if (_modRenames.TryGetValue(mod, out var record) && record.renameMappingData != null)
            {
--- a/Editor/Rename/SymbolRename.cs
+++ b/Editor/Rename/SymbolRename.cs
@ -18,12 +18,26 @@ namespace Obfuz

    public class SymbolRename
    {
+        class AssemblyReferenceInfo
+        {
+            public string name;
+
+            public bool needObfuscated;
+
+            public ModuleDef module;
+
+            public List<AssemblyReferenceInfo> referenceMeAssemblies;
+        }
+
        private readonly List<string> _obfuscationRuleFiles;
        private readonly string _mappingXmlPath;

        private AssemblyCache _assemblyCache;
-        private List<ObfuzAssemblyInfo> _obfuzAssemblies;
-        private HashSet<ModuleDef> _obfuscatedModules = new HashSet<ModuleDef>();
+
+        private List<ModuleDef> _toObfuscatedModules;
+        private List<ModuleDef> _obfuscatedAndNotObfuscatedModules;
+        private List<AssemblyReferenceInfo> _obfuzAssemblies;
+        private HashSet<ModuleDef> _toObfuscatedModuleSet;
        private ObfuscateRuleConfig _obfuscateRuleConfig;
        private IRenamePolicy _renamePolicy;
        private INameMaker _nameMaker;
@ -50,19 +64,49 @@ namespace Obfuz
        public void Init(ObfuscatorContext ctx)
        {
            _assemblyCache = ctx.assemblyCache;
-            _obfuzAssemblies = ctx.assemblies;
+            _toObfuscatedModules = ctx.toObfuscatedModules;
+            _obfuscatedAndNotObfuscatedModules = ctx.obfuscatedAndNotObfuscatedModules;
+            _toObfuscatedModuleSet = ctx.toObfuscatedModules.ToHashSet();
+            _obfuzAssemblies = BuildAssemblyReferenceInfos(ctx);
            _obfuscateRuleConfig = new ObfuscateRuleConfig(ctx.toObfuscatedAssemblyNames);
            _obfuscateRuleConfig.LoadXmls(_obfuscationRuleFiles);
            _renamePolicy = new CacheRenamePolicy(new CombineRenamePolicy(new SystemRenamePolicy(), new UnityRenamePolicy(), _obfuscateRuleConfig));
            _nameMaker = NameMakerFactory.CreateNameMakerBaseASCIICharSet();
-
-            foreach (var mod in ctx.assemblies)
-            {
-                _obfuscatedModules.Add(mod.module);
-            }
            BuildCustomAttributeArguments();
        }

+        private static List<AssemblyReferenceInfo> BuildAssemblyReferenceInfos(ObfuscatorContext ctx)
+        {
+            var obfuzAssemblies = new List<AssemblyReferenceInfo>();
+            foreach (ModuleDef mod in ctx.obfuscatedAndNotObfuscatedModules)
+            {
+                var obfuzAsm = new AssemblyReferenceInfo
+                {
+                    name = mod.Assembly.Name,
+                    needObfuscated = ctx.toObfuscatedModules.Contains(mod),
+                    module = mod,
+                    referenceMeAssemblies = new List<AssemblyReferenceInfo>(),
+                };
+                obfuzAsm.referenceMeAssemblies.Add(obfuzAsm);
+                obfuzAssemblies.Add(obfuzAsm);
+            }
+
+            var assByName = obfuzAssemblies.ToDictionary(x => x.name);
+            foreach (var ass in obfuzAssemblies)
+            {
+                foreach (var refAss in ass.module.GetAssemblyRefs())
+                {
+                    string refAssName = refAss.Name;
+                    if (assByName.TryGetValue(refAssName, out var refAssembly))
+                    {
+                        //UnityEngine.Debug.Log($"assembly:{ass.name} reference to {refAssName}");
+                        refAssembly.referenceMeAssemblies.Add(ass);
+                    }
+                }
+            }
+            return obfuzAssemblies;
+        }
+
        private void CollectCArgumentWithTypeOf(IHasCustomAttribute meta, List<CustomAttributeInfo> customAttributes)
        {
            int index = 0;
@ -94,11 +138,11 @@ namespace Obfuz

        private void BuildCustomAttributeArguments()
        {
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _obfuscatedAndNotObfuscatedModules)
            {
                var customAttributes = new List<CustomAttributeInfo>();
-                CollectCArgumentWithTypeOf(ass.module, customAttributes);
-                foreach (TypeDef type in ass.module.GetTypes())
+                CollectCArgumentWithTypeOf(mod, customAttributes);
+                foreach (TypeDef type in mod.GetTypes())
                {
                    CollectCArgumentWithTypeOf(type, customAttributes);
                    foreach (FieldDef field in type.Fields)
@ -126,13 +170,13 @@ namespace Obfuz
                    }
                }

-                _customAttributeArgumentsWithTypeByMods.Add(ass.module, customAttributes);
+                _customAttributeArgumentsWithTypeByMods.Add(mod, customAttributes);
            }
        }

        public void Process()
        {
-            _renameRecordMap.Init(_obfuzAssemblies, _nameMaker);
+            _renameRecordMap.Init(_toObfuscatedModules, _nameMaker);
            RenameModules();
            RenameTypes();
            RenameFields();
@ -141,7 +185,7 @@ namespace Obfuz
            RenameEvents();
        }

-        private List<ObfuzAssemblyInfo> GetReferenceMeAssemblies(ModuleDef mod)
+        private List<AssemblyReferenceInfo> GetReferenceMeAssemblies(ModuleDef mod)
        {
            return _obfuzAssemblies.Find(ass => ass.module == mod).referenceMeAssemblies;
        }
@ -149,11 +193,11 @@ namespace Obfuz
        private void RenameModules()
        {
            Debug.Log("Rename Modules begin");
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                if (_renamePolicy.NeedRename(ass.module))
+                if (_renamePolicy.NeedRename(mod))
                {
-                    Rename(ass.module);
+                    Rename(mod);
                }
            }
            Debug.Log("Rename Modules end");
@ -169,9 +213,9 @@ namespace Obfuz

        private void BuildRefTypeDefMetasMap(Dictionary<TypeDef, RefTypeDefMetas> refTypeDefMetasMap)
        {
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                foreach (TypeRef typeRef in ass.module.GetTypeRefs())
+                foreach (TypeRef typeRef in mod.GetTypeRefs())
                {
                    TypeDef typeDef = typeRef.ResolveThrow();
                    if (!refTypeDefMetasMap.TryGetValue(typeDef, out var typeDefMetas))
@ -244,9 +288,9 @@ namespace Obfuz
            BuildRefTypeDefMetasMap(_refTypeRefMetasMap);
            _assemblyCache.EnableTypeDefCache = false;

-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                {
                    if (_renamePolicy.NeedRename(type))
                    {
@ -279,9 +323,9 @@ namespace Obfuz

        private void BuildRefFieldMetasMap(Dictionary<FieldDef, RefFieldMetas> refFieldMetasMap)
        {
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                foreach (MemberRef memberRef in ass.module.GetMemberRefs())
+                foreach (MemberRef memberRef in mod.GetMemberRefs())
                {
                    if (!memberRef.IsFieldRef)
                    {
@ -348,9 +392,9 @@ namespace Obfuz
            var refFieldMetasMap = new Dictionary<FieldDef, RefFieldMetas>();
            BuildRefFieldMetasMap(refFieldMetasMap);

-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                {
                    foreach (FieldDef field in type.Fields)
                    {
@ -371,9 +415,9 @@ namespace Obfuz

        private void BuildRefMethodMetasMap(Dictionary<MethodDef, RefMethodMetas> refMethodMetasMap)
        {
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                foreach (MemberRef memberRef in ass.module.GetMemberRefs())
+                foreach (MemberRef memberRef in mod.GetMemberRefs())
                {
                    if (!memberRef.IsMethodRef)
                    {
@ -410,9 +454,9 @@ namespace Obfuz
            var virtualMethods = new List<MethodDef>();
            var refMethodMetasMap = new Dictionary<MethodDef, RefMethodMetas>();
            BuildRefMethodMetasMap(refMethodMetasMap);
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                {
                    _virtualMethodGroupCalculator.CalculateType(type);
                    foreach (MethodDef method in type.Methods)
@ -444,7 +488,7 @@ namespace Obfuz
                VirtualMethodGroup group = _virtualMethodGroupCalculator.GetMethodGroup(method);
                if (!groupNeedRenames.TryGetValue(group, out var needRename))
                {
-                    needRename = group.methods.All(m => _obfuscatedModules.Contains(m.DeclaringType.Module) && _renamePolicy.NeedRename(m));
+                    needRename = group.methods.All(m => _toObfuscatedModuleSet.Contains(m.DeclaringType.Module) && _renamePolicy.NeedRename(m));
                    groupNeedRenames.Add(group, needRename);
                    if (needRename)
                    {
@ -522,9 +566,9 @@ namespace Obfuz
            Debug.Log("Rename properties begin");
            var refPropertyMetasMap = new Dictionary<PropertyDef, RefPropertyMetas>();
            BuildRefPropertyMetasMap(refPropertyMetasMap);
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                {
                    foreach (PropertyDef property in type.Properties)
                    {
@ -541,9 +585,9 @@ namespace Obfuz
        private void RenameEvents()
        {
            Debug.Log("Rename events begin");
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
            {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                {
                    foreach (EventDef eventDef in type.Events)
                    {
@ -557,7 +601,7 @@ namespace Obfuz
            Debug.Log("Rename events begin");
        }

-        private void Rename(ModuleDefMD mod)
+        private void Rename(ModuleDef mod)
        {
            string oldName = mod.Assembly.Name;
            string newName = _renameRecordMap.TryGetExistRenameMapping(mod, out var n) ? n :  _nameMaker.GetNewName(mod, oldName);
@ -565,7 +609,7 @@ namespace Obfuz
            mod.Assembly.Name = newName;
            mod.Name = $"{newName}.dll";
            //Debug.Log($"rename module. oldName:{oldName} newName:{newName}");
-            foreach (ObfuzAssemblyInfo ass in GetReferenceMeAssemblies(mod))
+            foreach (AssemblyReferenceInfo ass in GetReferenceMeAssemblies(mod))
            {
                foreach (AssemblyRef assRef in ass.module.GetAssemblyRefs())
                {
--- a/Editor/Utils/PathAssemblyResolver.cs
+++ b/Editor/Utils/PathAssemblyResolver.cs
@ -24,7 +24,7 @@ namespace Obfuz
                string assPath = Path.Combine(path, assemblyName + ".dll");
                if (File.Exists(assPath))
                {
-                    //Debug.Log($"resolve {assemblyName} at {assPath}");
+                    Debug.Log($"resolve {assemblyName} at {assPath}");
                    return assPath;
                }
            }