混淆配置

Editor/NameMatcher.cs

@@ -0,0 +1,37 @@
+using System.Text.RegularExpressions;
+
+namespace Obfuz
+{
+    public class NameMatcher
+    {
+        private readonly string _str;
+        private readonly Regex _regex;
+
+        public string NameOrPattern => _str;
+
+        public NameMatcher(string nameOrPattern)
+        {
+            _str = nameOrPattern;
+            _regex = nameOrPattern.Contains('*') || nameOrPattern.Contains('?') ? new Regex(WildcardToRegex(nameOrPattern)) : null;
+        }
+
+        public static string WildcardToRegex(string pattern)
+        {
+            return "^" + Regex.Escape(pattern).
+            Replace("\\*", ".*").
+            Replace("\\?", ".") + "$";
+        }
+
+        public bool IsMatch(string name)
+        {
+            if (_regex != null)
+            {
+                return _regex.IsMatch(name);
+            }
+            else
+            {
+                return _str == name;
+            }
+        }
+    }
+}

Editor/ObfuscateRuleConfig.cs

@@ -10,6 +10,7 @@ using UnityEngine;
 
 namespace Obfuz
 {
+
     public class ObfuscateRuleConfig : IRenamePolicy
     {
         enum ObfuscationType
@@ -42,9 +43,9 @@ namespace Obfuz
 
         enum ModifierType
         {
-            Public = 0x1,
+            Private = 0,
-            NotPublic = 0x2,
+            Protected = 1,
-            All = 0x3,
+            Public = 2,
         }
 
         interface IRule
@@ -54,7 +55,7 @@ namespace Obfuz
 
         class MethodRuleSpec
         {
-            public string namePattern;
+            public NameMatcher nameMatcher;
             public ModifierType modifierType;
             public MethodRule rule;
         }
@@ -69,7 +70,7 @@ namespace Obfuz
 
         class FieldRuleSpec
         {
-            public string namePattern;
+            public NameMatcher nameMatcher;
             public ModifierType modifierType;
             public FieldRule rule;
         }
@@ -82,8 +83,7 @@ namespace Obfuz
 
         class PropertyRuleSpec
         {
-            public string namePattern;
+            public NameMatcher nameMatcher;
-            public ModifierType modifierType;
             public PropertyRule rule;
         }
 
@@ -91,14 +91,13 @@ namespace Obfuz
         {
             public string ruleName;
             public bool obfuscateName;
-            public bool obfuscateGetter;
+            public MethodRuleSpec getter;
-            public bool obfuscateSetter;
+            public MethodRuleSpec setter;
         }
 
         class EventRuleSpec
         {
-            public string namePattern;
+            public NameMatcher nameMatcher;
-            public ModifierType modifierType;
             public EventRule rule;
         }
 
@@ -106,14 +105,14 @@ namespace Obfuz
         {
             public string ruleName;
             public bool obfuscateName;
-            public bool obfuscateAdd;
+            public MethodRuleSpec add;
-            public bool obfuscateRemove;
+            public MethodRuleSpec remove;
-            public bool obfuscateFire;
+            public MethodRuleSpec fire;
         }
 
         class TypeRuleSpec
         {
-            public string namePattern;
+            public NameMatcher nameMatcher;
             public ModifierType modifierType;
             public TypeRule rule;
         }
@@ -163,73 +162,6 @@ namespace Obfuz
 
         public List<string> ObfuscatedAssemblyNames => _assemblyRuleSpecs.Keys.ToList();
 
-        private static readonly EventRule s_defaultEventRule = new EventRule
-        {
-            ruleName = "default",
-            obfuscateName = true,
-            obfuscateAdd = true,
-            obfuscateRemove = true,
-            obfuscateFire = true,
-        };
-
-        private static readonly PropertyRule s_defaultPropertyRule = new PropertyRule
-        {
-            ruleName = "default",
-            obfuscateName = true,
-            obfuscateGetter = true,
-            obfuscateSetter = true,
-        };
-
-        private static readonly MethodRule s_defaultMethodRule = new MethodRule
-        {
-            ruleName = "default",
-            obfuscateName = true,
-            obfuscateParam = true,
-            obfuscateBody = true,
-        };
-
-        private static readonly FieldRule s_defaultFieldRule = new FieldRule
-        {
-            ruleName = "default",
-            obfuscateName = true,
-        };
-
-        private static readonly TypeRule s_defaultTypeRule = new TypeRule
-        {
-            ruleName = "default",
-            obfuscateName = true,
-            obfuscateNamespace = true,
-            nestTypeRuleSpecs = new List<TypeRuleSpec>(),
-            fieldRuleSpecs = new List<FieldRuleSpec>() { new FieldRuleSpec { rule = s_defaultFieldRule} },
-            methodRuleSpecs = new List<MethodRuleSpec>() { new MethodRuleSpec { rule = s_defaultMethodRule} },
-            propertyRuleSpecs = new List<PropertyRuleSpec>() {  new PropertyRuleSpec {  rule = s_defaultPropertyRule} },
-            eventRuleSpecs = new List<EventRuleSpec>() {  new EventRuleSpec { rule = s_defaultEventRule} },
-        };
-
-        private static readonly AssemblyRule s_defaultAssemblyRule = new AssemblyRule
-        {
-            ruleName = "default",
-            obfuscateName = false,
-            typeRuleSpecs = new List<TypeRuleSpec>() { new TypeRuleSpec {  rule = s_defaultTypeRule} },
-        };
-
-
-        private static readonly EventRule s_noneEventRule = new EventRule
-        {
-            ruleName = "none",
-            obfuscateName = false,
-            obfuscateAdd = false,
-            obfuscateRemove = false,
-            obfuscateFire = false,
-        };
-
-        private static readonly PropertyRule s_nonePropertyRule = new PropertyRule
-        {
-            ruleName = "none",
-            obfuscateName = false,
-            obfuscateGetter = false,
-            obfuscateSetter = false,
-        };
 
         private static readonly MethodRule s_noneMethodRule = new MethodRule
         {
@@ -239,6 +171,23 @@ namespace Obfuz
             obfuscateBody = false,
         };
 
+        private static readonly EventRule s_noneEventRule = new EventRule
+        {
+            ruleName = "none",
+            obfuscateName = false,
+            add = new MethodRuleSpec { rule = s_noneMethodRule},
+            remove = new MethodRuleSpec { rule = s_noneMethodRule },
+            fire = new MethodRuleSpec { rule = s_noneMethodRule },
+        };
+
+        private static readonly PropertyRule s_nonePropertyRule = new PropertyRule
+        {
+            ruleName = "none",
+            obfuscateName = false,
+            getter = new MethodRuleSpec { rule = s_noneMethodRule },
+            setter = new MethodRuleSpec { rule = s_noneMethodRule },
+        };
+
         private static readonly FieldRule s_noneFieldRule = new FieldRule
         {
             ruleName = "none",
@@ -261,15 +210,11 @@ namespace Obfuz
         {
             ruleName = "none",
             obfuscateName = false,
-            typeRuleSpecs = null,
+            typeRuleSpecs = new List<TypeRuleSpec> { new TypeRuleSpec { rule = s_noneTypeRule } },
         };
 
         static ObfuscateRuleConfig()
         {
-            s_defaultTypeRule.nestTypeRuleSpecs.Add(new TypeRuleSpec
-            {
-                rule = s_defaultTypeRule,
-            });
             s_noneTypeRule.nestTypeRuleSpecs.Add(new TypeRuleSpec
             {
                 rule = s_noneTypeRule,
@@ -282,19 +227,6 @@ namespace Obfuz
             XmlElement element;
             if (!string.IsNullOrEmpty(ruleName))
             {
-                if (ruleName == "default")
-                {
-                    switch (ruleType)
-                    {
-                        case RuleType.Assembly: return s_defaultAssemblyRule;
-                        case RuleType.Type: return s_defaultTypeRule;
-                        case RuleType.Method: return s_defaultMethodRule;
-                        case RuleType.Field: return s_defaultFieldRule;
-                        case RuleType.Property: return s_defaultPropertyRule;
-                        case RuleType.Event: return s_defaultEventRule;
-                        default: throw new Exception($"Invalid rule type {ruleType}");
-                    }
-                }
                 if (ruleName == "none")
                 {
                     switch (ruleType)
@@ -351,16 +283,16 @@ namespace Obfuz
             return rule;
         }
 
-        private static bool ParseBool(string str, bool defaultValue)
+        private static bool ParseBoolNoneOrFalse(string str)
         {
             if (string.IsNullOrEmpty(str))
             {
-                return defaultValue;
+                return true;
             }
             switch (str.ToLowerInvariant())
             {
                 case "1":
-                case "true": return true;
+                case "true": throw new Exception($"Invalid bool value '{str}', only accept '0' or 'false' because default is true"); // true is default
                 case "0":
                 case "false": return false;
                 default: throw new Exception($"Invalid bool value {str}");
@@ -371,7 +303,7 @@ namespace Obfuz
         {
             var rule = new AssemblyRule();
             rule.ruleName = ruleName;
-            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), false);
+            rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob:name"));
             rule.typeRuleSpecs = new List<TypeRuleSpec>();
             foreach (XmlNode node in element.ChildNodes)
             {
@@ -384,8 +316,8 @@ namespace Obfuz
                     throw new Exception($"Invalid xml file, unknown node {childElement.Name}");
                 }
                 var typeRuleSpec = new TypeRuleSpec();
-                typeRuleSpec.namePattern = childElement.GetAttribute("name");
+                typeRuleSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
-                typeRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                typeRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifier"));
                 typeRuleSpec.rule = (TypeRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Type, childElement);
                 rule.typeRuleSpecs.Add(typeRuleSpec);
             }
@@ -396,8 +328,8 @@ namespace Obfuz
         {
             var rule = new TypeRule();
             rule.ruleName = ruleName;
-            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob:name"));
-            rule.obfuscateNamespace = ParseBool(element.GetAttribute("ob-namespace"), true);
+            rule.obfuscateNamespace = ParseBoolNoneOrFalse(element.GetAttribute("ob:namespace"));
             rule.nestTypeRuleSpecs = new List<TypeRuleSpec>();
             rule.fieldRuleSpecs = new List<FieldRuleSpec>();
             rule.methodRuleSpecs = new List<MethodRuleSpec>();
@@ -414,8 +346,8 @@ namespace Obfuz
                     case "nesttype":
                     {
                         var typeRuleSpec = new TypeRuleSpec();
-                        typeRuleSpec.namePattern = childElement.GetAttribute("namePattern");
+                        typeRuleSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
-                        typeRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                        typeRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifier"));
                         typeRuleSpec.rule = (TypeRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Type, childElement);
                         rule.nestTypeRuleSpecs.Add(typeRuleSpec);
                         break;
@@ -423,34 +355,28 @@ namespace Obfuz
                     case "field":
                     {
                         var fieldRuleSpec = new FieldRuleSpec();
-                        fieldRuleSpec.namePattern = childElement.GetAttribute("namePattern");
+                        fieldRuleSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
-                        fieldRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                        fieldRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifier"));
                         fieldRuleSpec.rule = (FieldRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Field, childElement);
                         rule.fieldRuleSpecs.Add(fieldRuleSpec);
                         break;
                     }
                     case "method":
                     {
-                        var methodRuleSpec = new MethodRuleSpec();
+                        rule.methodRuleSpecs.Add(ParseMethodRuleSpec(childElement));
-                        methodRuleSpec.namePattern = childElement.GetAttribute("namePattern");
-                        methodRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
-                        methodRuleSpec.rule = (MethodRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Method, childElement);
-                        rule.methodRuleSpecs.Add(methodRuleSpec);
                         break;
                     }
                     case "property":
                     {
-                        var propertyRulerRef = new PropertyRuleSpec();
+                        var propertyRulerSpec = new PropertyRuleSpec();
-                        propertyRulerRef.namePattern = childElement.GetAttribute("namePattern");
+                        propertyRulerSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
-                        propertyRulerRef.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                        propertyRulerSpec.rule = (PropertyRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Property, childElement);
-                        propertyRulerRef.rule = (PropertyRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Property, childElement);
                         break;
                     }
                     case "event":
                     {
                         var eventRuleSpec = new EventRuleSpec();
-                        eventRuleSpec.namePattern = childElement.GetAttribute("namePattern");
+                        eventRuleSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
-                        eventRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
                         eventRuleSpec.rule = (EventRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Event, childElement);
                         rule.eventRuleSpecs.Add(eventRuleSpec);
                         break;
@@ -461,13 +387,22 @@ namespace Obfuz
             return rule;
         }
 
+        private MethodRuleSpec ParseMethodRuleSpec(XmlElement el)
+        {
+            var methodRuleSpec = new MethodRuleSpec();
+            methodRuleSpec.nameMatcher = new NameMatcher(el.GetAttribute("name"));
+            methodRuleSpec.modifierType = ParseModifierType(el.GetAttribute("modifier"));
+            methodRuleSpec.rule = (MethodRule)GetOrParseRule(el.GetAttribute("rule"), RuleType.Method, el);
+            return methodRuleSpec;
+        }
+
         private MethodRule ParseMethodRule(string ruleName, XmlElement element)
         {
             var rule = new MethodRule();
             rule.ruleName = ruleName;
-            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob:name"));
-            rule.obfuscateParam = ParseBool(element.GetAttribute("ob-param"), true);
+            rule.obfuscateParam = ParseBoolNoneOrFalse(element.GetAttribute("ob:param"));
-            rule.obfuscateBody = ParseBool(element.GetAttribute("ob-body"), true);
+            rule.obfuscateBody = ParseBoolNoneOrFalse(element.GetAttribute("ob:body"));
             return rule;
         }
 
@@ -475,7 +410,7 @@ namespace Obfuz
         {
             var rule = new FieldRule();
             rule.ruleName = ruleName;
-            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob:name"));
             return rule;
         }
 
@@ -483,9 +418,37 @@ namespace Obfuz
         {
             var rule = new PropertyRule();
             rule.ruleName = ruleName;
-            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob:name"));
-            rule.obfuscateGetter = ParseBool(element.GetAttribute("ob-getter"), true);
+
-            rule.obfuscateSetter = ParseBool(element.GetAttribute("ob-setter"), true);
+            foreach (XmlNode node in element.ChildNodes)
+            {
+                if (node is not XmlElement childElement)
+                {
+                    continue;
+                }
+                switch (node.Name)
+                {
+                    case "getter":
+                    {
+                        if (rule.getter != null)
+                        {
+                            throw new Exception($"Invalid xml file, duplicate getter rule in property rule {ruleName}");
+                        }
+                        rule.getter = ParseMethodRuleSpec(childElement);
+                        break;
+                    }
+                    case "setter":
+                    {
+                        if (rule.setter != null)
+                        {
+                            throw new Exception($"Invalid xml file, duplicate setter rule in property rule {ruleName}");
+                        }
+                        rule.setter = ParseMethodRuleSpec(childElement);
+                        break;
+                    }
+                    default: throw new Exception($"Invalid xml file, unknown node {childElement.Name} in property rule {ruleName}");
+                }
+            }
             return rule;
         }
 
@@ -493,10 +456,47 @@ namespace Obfuz
         {
             var rule = new EventRule();
             rule.ruleName = ruleName;
-            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob:name"));
-            rule.obfuscateAdd = ParseBool(element.GetAttribute("ob-add"), true);
+
-            rule.obfuscateRemove = ParseBool(element.GetAttribute("ob-remove"), true);
+            foreach (XmlNode node in element.ChildNodes)
-            rule.obfuscateFire = ParseBool(element.GetAttribute("ob-fire"), true);
+            {
+                if (node is not XmlElement childElement)
+                {
+                    continue;
+                }
+                switch (node.Name)
+                {
+                    case "add":
+                    {
+                        if (rule.add != null)
+                        {
+                            throw new Exception($"Invalid xml file, duplicate getter rule in property rule {ruleName}");
+                        }
+                        rule.add = ParseMethodRuleSpec(childElement);
+                        break;
+                    }
+                    case "remove":
+                    {
+                        if (rule.remove != null)
+                        {
+                            throw new Exception($"Invalid xml file, duplicate setter rule in property rule {ruleName}");
+                        }
+                        rule.remove = ParseMethodRuleSpec(childElement);
+                        break;
+                    }
+                    case "fire":
+                    {
+                        if (rule.fire != null)
+                        {
+                            throw new Exception($"Invalid xml file, duplicate fire rule in property rule {ruleName}");
+                        }
+                        rule.fire = ParseMethodRuleSpec(childElement);
+                        break;
+                    }
+                    default: throw new Exception($"Invalid xml file, unknown node {childElement.Name} in event rule {ruleName}");
+                }
+            }
+
             return rule;
         }
 
@@ -551,13 +551,13 @@ namespace Obfuz
         {
             if (string.IsNullOrEmpty(modifierType))
             {
-                return ModifierType.All;
+                return ModifierType.Private;
             }
             switch (modifierType)
             {
                 case "public": return ModifierType.Public;
-                case "notPublic": return ModifierType.NotPublic;
+                case "protected": return ModifierType.Protected;
-                case "all": return ModifierType.All;
+                case "private": return ModifierType.Private;
                 default: throw new Exception($"Invalid modifier type {modifierType}");
             }
         }
@@ -607,37 +607,272 @@ namespace Obfuz
 
         public bool NeedRename(ModuleDefMD mod)
         {
+            //string name = mod.Assembly.Name;
+            //if (!_assemblyRuleSpecs.TryGetValue(name, out var assemblyRuleSpec))
+            //{
+            //    return false;
+            //}
+            //return assemblyRuleSpec.rule.obfuscateName;
+
+            // TODO support rename assembly
             return false;
         }
 
+        private ModifierType ComputeModifierType(TypeAttributes visibility)
+        {
+            if (visibility == TypeAttributes.NotPublic || visibility == TypeAttributes.NestedPrivate)
+            {
+                return ModifierType.Private;
+            }
+            if (visibility == TypeAttributes.Public || visibility == TypeAttributes.NestedPublic)
+            {
+                return ModifierType.Public;
+            }
+            return ModifierType.Protected;
+        }
+
+        private ModifierType ComputeModifierType(FieldAttributes access)
+        {
+            if (access == FieldAttributes.Private || access == FieldAttributes.PrivateScope)
+            {
+                return ModifierType.Private;
+            }
+            if (access == FieldAttributes.Public)
+            {
+                return ModifierType.Public;
+            }
+            return ModifierType.Protected;
+        }
+
+        //private ModifierType ComputeModifierType(MethodAttributes access)
+        //{
+        //    if (access == MethodAttributes.Private || access == MethodAttributes.PrivateScope)
+        //    {
+        //        return ModifierType.Private;
+        //    }
+        //    if (access == MethodAttributes.Public)
+        //    {
+        //        return ModifierType.Public;
+        //    }
+        //    return ModifierType.Protected;
+        //}
+
+        private bool MatchModifier(ModifierType modifierType, TypeDef typeDef)
+        {
+            return modifierType <= ComputeModifierType(typeDef.Visibility);
+        }
+
+        private bool MatchModifier(ModifierType modifierType, FieldDef fieldDef)
+        {
+            return modifierType <= ComputeModifierType(fieldDef.Access);
+        }
+
+        private bool MatchModifier(ModifierType modifierType, MethodDef methodDef)
+        {
+            return modifierType <= ComputeModifierType((FieldAttributes)methodDef.Access);
+        }
+
+        //private bool MatchModifier(ModifierType modifierType, PropertyDef propertyDef)
+        //{
+        //    return modifierType <= ComputeModifierType((FieldAttributes)propertyDef.Attributes);
+        //}
+
+        private class MethodComputeCache
+        {
+            public bool obfuscateName = true;
+            public bool obfuscateParam = true;
+            public bool obfuscateBody = true;
+        }
+
+        private class TypeDefComputeCache
+        {
+            public bool obfuscateName = true;
+            public bool obfuscateNamespace = true;
+
+            public readonly Dictionary<MethodDef, MethodComputeCache> methods = new Dictionary<MethodDef, MethodComputeCache>();
+
+            public readonly HashSet<FieldDef> notObfuscatedFields = new HashSet<FieldDef>();
+
+            public readonly HashSet<PropertyDef> notObfuscatedProperties = new HashSet<PropertyDef>();
+
+            public readonly HashSet<EventDef> notObfuscatedEvents = new HashSet<EventDef>();
+        }
+
+        private readonly Dictionary<TypeDef, TypeDefComputeCache> _typeRenameCache = new Dictionary<TypeDef, TypeDefComputeCache>();
+
+        private TypeDefComputeCache GetOrCreateTypeDefRenameComputeCache(TypeDef typeDef)
+        {
+            if (_typeRenameCache.TryGetValue(typeDef, out var cache))
+            {
+                return cache;
+            }
+            cache = new TypeDefComputeCache();
+            _typeRenameCache.Add(typeDef, cache);
+
+            if (!_assemblyRuleSpecs.TryGetValue(typeDef.Module.Assembly.Name, out var assemblyRuleSpec))
+            {
+                return cache;
+            }
+            string typeName = typeDef.FullName;
+            var totalMethodSpecs = new List<MethodRuleSpec>();
+            var totalMethodSpecFromPropertyAndEvents = new List<(MethodDef, MethodRuleSpec)>();
+            foreach (var typeRule in assemblyRuleSpec.rule.typeRuleSpecs)
+            {
+                if (!typeRule.nameMatcher.IsMatch(typeName) || !MatchModifier(typeRule.modifierType, typeDef))
+                {
+                    continue;
+                }
+                cache.obfuscateNamespace &= typeRule.rule.obfuscateNamespace;
+                cache.obfuscateName &= typeRule.rule.obfuscateName;
+
+                totalMethodSpecs.AddRange(typeRule.rule.methodRuleSpecs);
+
+                foreach (var eventDef in typeDef.Events)
+                {
+                    foreach (var eventRule in typeRule.rule.eventRuleSpecs)
+                    {
+                        if (!eventRule.nameMatcher.IsMatch(eventDef.Name))
+                        {
+                            continue;
+                        }
+                        if (!eventRule.rule.obfuscateName)
+                        {
+                            cache.notObfuscatedEvents.Add(eventDef);
+                        }
+                        if (eventDef.AddMethod != null && MatchModifier(eventRule.rule.add.modifierType, eventDef.AddMethod))
+                        {
+                            totalMethodSpecFromPropertyAndEvents.Add((eventDef.AddMethod,eventRule.rule.add));
+                        }
+                        if (eventDef.RemoveMethod != null && MatchModifier(eventRule.rule.remove.modifierType, eventDef.RemoveMethod))
+                        {
+                            totalMethodSpecFromPropertyAndEvents.Add((eventDef.RemoveMethod, eventRule.rule.remove));
+                        }
+                        if (eventDef.InvokeMethod != null && MatchModifier(eventRule.rule.fire.modifierType, eventDef.InvokeMethod))
+                        {
+                            totalMethodSpecFromPropertyAndEvents.Add((eventDef.InvokeMethod, eventRule.rule.fire));
+                        }
+                    }
+                }
+                foreach (var propertyDef in typeDef.Properties)
+                {
+                    foreach (var propertyRule in typeRule.rule.propertyRuleSpecs)
+                    {
+                        if (!propertyRule.nameMatcher.IsMatch(propertyDef.Name))
+                        {
+                            continue;
+                        }
+                        if (!propertyRule.rule.obfuscateName)
+                        {
+                            cache.notObfuscatedProperties.Add(propertyDef);
+                        }
+                        if (propertyDef.GetMethod != null && MatchModifier(propertyRule.rule.getter.modifierType, propertyDef.GetMethod))
+                        {
+                            totalMethodSpecFromPropertyAndEvents.Add((propertyDef.GetMethod, propertyRule.rule.getter));
+                        }
+                        if (propertyDef.SetMethod != null && MatchModifier(propertyRule.rule.setter.modifierType, propertyDef.SetMethod))
+                        {
+                            totalMethodSpecFromPropertyAndEvents.Add((propertyDef.SetMethod, propertyRule.rule.setter));
+                        }
+                    }
+                }
+                
+                foreach (var fieldDef in typeDef.Fields)
+                {
+                    foreach (var fieldRule in typeRule.rule.fieldRuleSpecs)
+                    {
+                        if (fieldRule.nameMatcher.IsMatch(fieldDef.Name) && MatchModifier(fieldRule.modifierType, fieldDef) && !fieldRule.rule.obfuscateName)
+                        {
+                            cache.notObfuscatedFields.Add(fieldDef);
+                        }
+                    }
+                }
+                foreach (MethodDef methodDef in typeDef.Methods)
+                {
+                    foreach (var e in totalMethodSpecFromPropertyAndEvents)
+                    {
+                        if (e.Item1 != methodDef)
+                        {
+                            continue;
+                        }
+                        if (!cache.methods.TryGetValue(methodDef, out var methodCache))
+                        {
+                            methodCache = new MethodComputeCache();
+                            cache.methods.Add(methodDef, methodCache);
+                        }
+                        MethodRule methodRule = e.Item2.rule;
+                        methodCache.obfuscateName &= methodRule.obfuscateName;
+                        methodCache.obfuscateParam &= methodRule.obfuscateParam;
+                        methodCache.obfuscateBody &= methodRule.obfuscateBody;
+                    }
+                    foreach (MethodRuleSpec methodSpec in totalMethodSpecs)
+                    {
+                        if (!methodSpec.nameMatcher.IsMatch(methodDef.Name) || !MatchModifier(methodSpec.modifierType, methodDef))
+                        {
+                            continue;
+                        }
+                        if (!cache.methods.TryGetValue(methodDef, out var methodCache))
+                        {
+                            methodCache = new MethodComputeCache();
+                            cache.methods.Add(methodDef, methodCache);
+                        }
+                        MethodRule methodRule = methodSpec.rule;
+                        methodCache.obfuscateName &= methodRule.obfuscateName;
+                        methodCache.obfuscateParam &= methodRule.obfuscateParam;
+                        methodCache.obfuscateBody &= methodRule.obfuscateBody;
+                    }
+                }
+            }
+            return cache;
+        }
+
         public bool NeedRename(TypeDef typeDef)
         {
-            return true;
+            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
+            return cache.obfuscateName;
         }
 
         public bool NeedRename(MethodDef methodDef)
+        {
+            TypeDef typeDef = methodDef.DeclaringType;
+            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
+            if (!cache.methods.TryGetValue(methodDef, out var methodCache))
             {
                 return true;
             }
+            return methodCache.obfuscateName;
+        }
 
         public bool NeedRename(FieldDef fieldDef)
         {
-            return true;
+            TypeDef typeDef = fieldDef.DeclaringType;
+            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
+            return cache.notObfuscatedFields.Contains(fieldDef);
         }
 
         public bool NeedRename(PropertyDef propertyDef)
         {
-            return true;
+            TypeDef typeDef = propertyDef.DeclaringType;
+            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
+            return cache.notObfuscatedProperties.Contains(propertyDef);
         }
 
         public bool NeedRename(EventDef eventDef)
         {
-            return true;
+            TypeDef typeDef = eventDef.DeclaringType;
+            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
+            return cache.notObfuscatedEvents.Contains(eventDef);
         }
 
         public bool NeedRename(ParamDef paramDef)
+        {
+            MethodDef methodDef = paramDef.DeclaringMethod;
+            TypeDef typeDef = methodDef.DeclaringType;
+            TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
+            if (!cache.methods.TryGetValue(methodDef, out var methodCache))
             {
                 return true;
             }
+            return methodCache.obfuscateParam;
+        }
     }
 }

Editor/Rename/RenameRecordMap.cs

@@ -430,6 +430,7 @@ namespace Obfuz
                 }
                 root.AppendChild(assemblyNode);
             }
+            Directory.CreateDirectory(Path.GetDirectoryName(_mappingFile));
             doc.Save(_mappingFile);
             Debug.Log($"Mapping file saved to {Path.GetFullPath(_mappingFile)}");
         }
@@ -464,8 +465,6 @@ namespace Obfuz
             }
         }
 
-
-
         private void WriteTypeMapping(XmlElement assNode, string fullName, RenameMappingType type)
         {
             var typeNode = assNode.OwnerDocument.CreateElement("type");