支持xml配置

Editor/BuildProcess/ObfuzProcess.cs

@@ -68,14 +68,14 @@ namespace Obfuz
                     @"D:\UnityHubs\2022.3.60f1\Editor\Data\PlaybackEngines\windowsstandalonesupport\Variations\il2cpp\Managed",
                    backupPlayerScriptAssembliesPath,
                 },
-                ObfuscatedAssemblyNames = settings.obfuscatedAssemblyNames.ToList(),
+                ObfuscationRuleFiles = settings.aotRuleFiles.ToList(),
                 mappingXmlPath = settings.GetMappingFile(buildTarget),
                 outputDir = ObfuzSettings.Instance.GetObfuscatedAssemblyOutputDir(buildTarget),
             };
             var obfuz = new Obfuscator(opt);
             obfuz.Run();
 
-            foreach (var dllName in settings.obfuscatedAssemblyNames)
+            foreach (var dllName in obfuz.ObfuscatedAssemblyNames)
             {
                 string src = $"{opt.outputDir}/{dllName}.dll";
                 string dst = $"{originalPlayerScriptAssembliesPath}/{dllName}.dll";

Editor/Menus/HybridCLRMenu.cs

@@ -0,0 +1,16 @@
+
+#if USE_HYBRIDCLR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Obfuz.Menus
+{
+    public static class HybridCLRMenu
+    {
+    }
+}
+
+#endif

Editor/Menus/ObfuzMenu.cs

@@ -3,21 +3,15 @@ using UnityEngine;
 
 namespace Obfuz
 {
-    public static class MenuProvider
+    public static class ObfuzMenu
     {
 
-        [MenuItem("Obfuz/About", priority = 0)]
-        public static void OpenAbout() => Application.OpenURL("https://obfuz.doc.code-philosophy.com/docs/intro");
-
         [MenuItem("Obfuz/Settings...", priority = 61)]
         public static void OpenSettings() => SettingsService.OpenProjectSettings("Project/Obfuz");
 
         [MenuItem("Obfuz/Documents/Quick Start")]
         public static void OpenQuickStart() => Application.OpenURL("https://obfuz.doc.code-philosophy.com/docs/beginner/quickstart");
 
-        [MenuItem("Obfuz/Documents/Performance")]
-        public static void OpenPerformance() => Application.OpenURL("https://obfuz.doc.code-philosophy.com/docs/basic/performance");
-
         [MenuItem("Obfuz/Documents/FAQ")]
         public static void OpenFAQ() => Application.OpenURL("https://obfuz.doc.code-philosophy.com/docs/help/faq");
 
@@ -32,6 +26,9 @@ namespace Obfuz
 
         [MenuItem("Obfuz/Documents/Gitee")]
         public static void OpenGitee() => Application.OpenURL("https://gitee.com/focus-creative-games/obfuz");
+
+        [MenuItem("Obfuz/Documents/About")]
+        public static void OpenAbout() => Application.OpenURL("https://obfuz.doc.code-philosophy.com/docs/intro");
     }
 
 }

Editor/ObfuscateRuleConfig.cs

@@ -0,0 +1,643 @@
+using dnlib.DotNet;
+using Obfuz.Rename;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using UnityEngine;
+
+namespace Obfuz
+{
+    public class ObfuscateRuleConfig : IRenamePolicy
+    {
+        enum ObfuscationType
+        {
+            Name = 1,
+            Namespace = 2,
+            NestType = 3,
+            Method = 4,
+            Field = 5,
+            Property = 6,
+            Event = 7,
+            Param = 8,
+            MethodBody = 9,
+            Getter = 10,
+            Setter = 11,
+            Add = 12,
+            Remove = 13,
+            Fire = 14,
+        }
+
+        enum RuleType
+        {
+            Assembly = 1,
+            Type = 2,
+            Method = 3,
+            Field = 4,
+            Property = 5,
+            Event = 6,
+        }
+
+        enum ModifierType
+        {
+            Public = 0x1,
+            NotPublic = 0x2,
+            All = 0x3,
+        }
+
+        interface IRule
+        {
+
+        }
+
+        class MethodRuleSpec
+        {
+            public string namePattern;
+            public ModifierType modifierType;
+            public MethodRule rule;
+        }
+
+        class MethodRule : IRule
+        {
+            public string ruleName;
+            public bool obfuscateName;
+            public bool obfuscateParam;
+            public bool obfuscateBody;
+        }
+
+        class FieldRuleSpec
+        {
+            public string namePattern;
+            public ModifierType modifierType;
+            public FieldRule rule;
+        }
+
+        class FieldRule : IRule
+        {
+            public string ruleName;
+            public bool obfuscateName;
+        }
+
+        class PropertyRuleSpec
+        {
+            public string namePattern;
+            public ModifierType modifierType;
+            public PropertyRule rule;
+        }
+
+        class PropertyRule : IRule
+        {
+            public string ruleName;
+            public bool obfuscateName;
+            public bool obfuscateGetter;
+            public bool obfuscateSetter;
+        }
+
+        class EventRuleSpec
+        {
+            public string namePattern;
+            public ModifierType modifierType;
+            public EventRule rule;
+        }
+
+        class EventRule : IRule
+        {
+            public string ruleName;
+            public bool obfuscateName;
+            public bool obfuscateAdd;
+            public bool obfuscateRemove;
+            public bool obfuscateFire;
+        }
+
+        class TypeRuleSpec
+        {
+            public string namePattern;
+            public ModifierType modifierType;
+            public TypeRule rule;
+        }
+
+        class TypeRule : IRule
+        {
+            public string ruleName;
+
+            public bool obfuscateName;
+            public bool obfuscateNamespace;
+
+            public List<TypeRuleSpec> nestTypeRuleSpecs;
+            public List<FieldRuleSpec> fieldRuleSpecs;
+            public List<MethodRuleSpec> methodRuleSpecs;
+            public List<PropertyRuleSpec> propertyRuleSpecs;
+            public List<EventRuleSpec> eventRuleSpecs;
+        }
+
+        class AssemblyRule : IRule
+        {
+            public string ruleName;
+
+            public bool obfuscateName;
+
+            public List<TypeRuleSpec> typeRuleSpecs;
+        }
+
+        class AssemblyRuleSpec
+        {
+            public string assemblyName;
+            public AssemblyRule rule;
+        }
+
+        //class DefaultRule : IRule
+        //{
+            
+        //}
+
+        //private readonly static IRule _defaultRule = new DefaultRule();
+        //private readonly static IRule _noneRule = new DefaultRule();
+
+        private readonly Dictionary<(string, RuleType), IRule> _rules = new Dictionary<(string, RuleType), IRule>();
+
+        private readonly Dictionary<(string, RuleType), XmlElement> _rawRuleElements = new Dictionary<(string, RuleType), XmlElement>();
+
+        private readonly Dictionary<string, AssemblyRuleSpec> _assemblyRuleSpecs = new Dictionary<string, AssemblyRuleSpec>();
+
+        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
+        {
+            ruleName = "none",
+            obfuscateName = false,
+            obfuscateParam = false,
+            obfuscateBody = false,
+        };
+
+        private static readonly FieldRule s_noneFieldRule = new FieldRule
+        {
+            ruleName = "none",
+            obfuscateName = false,
+        };
+
+        private static readonly TypeRule s_noneTypeRule = new TypeRule
+        {
+            ruleName = "none",
+            obfuscateName = false,
+            obfuscateNamespace = false,
+            nestTypeRuleSpecs = new List<TypeRuleSpec>(),
+            fieldRuleSpecs = new List<FieldRuleSpec> {  new FieldRuleSpec { rule = s_noneFieldRule} },
+            methodRuleSpecs = new List<MethodRuleSpec> { new MethodRuleSpec { rule = s_noneMethodRule} },
+            propertyRuleSpecs = new List<PropertyRuleSpec> { new PropertyRuleSpec { rule = s_nonePropertyRule} },
+            eventRuleSpecs = new List<EventRuleSpec> { new EventRuleSpec { rule = s_noneEventRule} },
+        };
+
+        private static readonly AssemblyRule s_noneAssemblyRule = new AssemblyRule
+        {
+            ruleName = "none",
+            obfuscateName = false,
+            typeRuleSpecs = null,
+        };
+
+        static ObfuscateRuleConfig()
+        {
+            s_defaultTypeRule.nestTypeRuleSpecs.Add(new TypeRuleSpec
+            {
+                rule = s_defaultTypeRule,
+            });
+            s_noneTypeRule.nestTypeRuleSpecs.Add(new TypeRuleSpec
+            {
+                rule = s_noneTypeRule,
+            });
+        }
+
+        private IRule GetOrParseRule(string ruleName, RuleType ruleType, XmlElement ele)
+        {
+            IRule rule = null;
+            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)
+                    {
+                        case RuleType.Assembly: return s_noneAssemblyRule;
+                        case RuleType.Type: return s_noneTypeRule;
+                        case RuleType.Method: return s_noneMethodRule;
+                        case RuleType.Field: return s_noneFieldRule;
+                        case RuleType.Property: return s_nonePropertyRule;
+                        case RuleType.Event: return s_noneEventRule;
+                        default: throw new Exception($"Invalid rule type {ruleType}");
+                    }
+                }
+                if (_rules.TryGetValue((ruleName, ruleType), out rule))
+                {
+                    return rule;
+                }
+                if (!_rawRuleElements.TryGetValue((ruleName, ruleType), out element))
+                {
+                    throw new Exception($"Invalid xml file, rule {ruleName} type {ruleType} not found");
+                }
+            }
+            else
+            {
+                element = ele;
+            }
+            switch (ruleType)
+            {
+                case RuleType.Assembly:
+                rule = ParseAssemblyRule(ruleName, element);
+                break;
+                case RuleType.Type:
+                rule = ParseTypeRule(ruleName, element);
+                break;
+                case RuleType.Method:
+                rule = ParseMethodRule(ruleName, element);
+                break;
+                case RuleType.Field:
+                rule = ParseFieldRule(ruleName, element);
+                break;
+                case RuleType.Property:
+                rule = ParsePropertyRule(ruleName, element);
+                break;
+                case RuleType.Event:
+                rule = ParseEventRule(ruleName, element);
+                break;
+                default:
+                throw new Exception($"Invalid rule type {ruleType}");
+            }
+            if (!string.IsNullOrEmpty(ruleName))
+            {
+                _rules.Add((ruleName, ruleType), rule);
+            }
+            return rule;
+        }
+
+        private static bool ParseBool(string str, bool defaultValue)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                return defaultValue;
+            }
+            switch (str.ToLowerInvariant())
+            {
+                case "1":
+                case "true": return true;
+                case "0":
+                case "false": return false;
+                default: throw new Exception($"Invalid bool value {str}");
+            }
+        }
+
+        private AssemblyRule ParseAssemblyRule(string ruleName, XmlElement element)
+        {
+            var rule = new AssemblyRule();
+            rule.ruleName = ruleName;
+            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), false);
+            rule.typeRuleSpecs = new List<TypeRuleSpec>();
+            foreach (XmlNode node in element.ChildNodes)
+            {
+                if (node is not XmlElement childElement)
+                {
+                    continue;
+                }
+                if (childElement.Name != "type")
+                {
+                    throw new Exception($"Invalid xml file, unknown node {childElement.Name}");
+                }
+                var typeRuleSpec = new TypeRuleSpec();
+                typeRuleSpec.namePattern = childElement.GetAttribute("name");
+                typeRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                typeRuleSpec.rule = (TypeRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Type, childElement);
+                rule.typeRuleSpecs.Add(typeRuleSpec);
+            }
+            return rule;
+        }
+
+        private TypeRule ParseTypeRule(string ruleName, XmlElement element)
+        {
+            var rule = new TypeRule();
+            rule.ruleName = ruleName;
+            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateNamespace = ParseBool(element.GetAttribute("ob-namespace"), true);
+            rule.nestTypeRuleSpecs = new List<TypeRuleSpec>();
+            rule.fieldRuleSpecs = new List<FieldRuleSpec>();
+            rule.methodRuleSpecs = new List<MethodRuleSpec>();
+            rule.propertyRuleSpecs = new List<PropertyRuleSpec>();
+            rule.eventRuleSpecs = new List<EventRuleSpec>();
+            foreach (XmlNode node in element.ChildNodes)
+            {
+                if (node is not XmlElement childElement)
+                {
+                    continue;
+                }
+                switch (childElement.Name)
+                {
+                    case "nesttype":
+                    {
+                        var typeRuleSpec = new TypeRuleSpec();
+                        typeRuleSpec.namePattern = childElement.GetAttribute("namePattern");
+                        typeRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                        typeRuleSpec.rule = (TypeRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Type, childElement);
+                        rule.nestTypeRuleSpecs.Add(typeRuleSpec);
+                        break;
+                    }
+                    case "field":
+                    {
+                        var fieldRuleSpec = new FieldRuleSpec();
+                        fieldRuleSpec.namePattern = childElement.GetAttribute("namePattern");
+                        fieldRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                        fieldRuleSpec.rule = (FieldRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Field, childElement);
+                        rule.fieldRuleSpecs.Add(fieldRuleSpec);
+                        break;
+                    }
+                    case "method":
+                    {
+                        var methodRuleSpec = new MethodRuleSpec();
+                        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();
+                        propertyRulerRef.namePattern = childElement.GetAttribute("namePattern");
+                        propertyRulerRef.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                        propertyRulerRef.rule = (PropertyRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Property, childElement);
+                        break;
+                    }
+                    case "event":
+                    {
+                        var eventRuleSpec = new EventRuleSpec();
+                        eventRuleSpec.namePattern = childElement.GetAttribute("namePattern");
+                        eventRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifierType"));
+                        eventRuleSpec.rule = (EventRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Event, childElement);
+                        rule.eventRuleSpecs.Add(eventRuleSpec);
+                        break;
+                    }
+                    default: throw new Exception($"Invalid xml file, unknown node {childElement.Name} in type rule {ruleName}");
+                }
+            }
+            return rule;
+        }
+
+        private MethodRule ParseMethodRule(string ruleName, XmlElement element)
+        {
+            var rule = new MethodRule();
+            rule.ruleName = ruleName;
+            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateParam = ParseBool(element.GetAttribute("ob-param"), true);
+            rule.obfuscateBody = ParseBool(element.GetAttribute("ob-body"), true);
+            return rule;
+        }
+
+        private FieldRule ParseFieldRule(string ruleName, XmlElement element)
+        {
+            var rule = new FieldRule();
+            rule.ruleName = ruleName;
+            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            return rule;
+        }
+
+        private PropertyRule ParsePropertyRule(string ruleName, XmlElement element)
+        {
+            var rule = new PropertyRule();
+            rule.ruleName = ruleName;
+            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateGetter = ParseBool(element.GetAttribute("ob-getter"), true);
+            rule.obfuscateSetter = ParseBool(element.GetAttribute("ob-setter"), true);
+            return rule;
+        }
+
+        private EventRule ParseEventRule(string ruleName, XmlElement element)
+        {
+            var rule = new EventRule();
+            rule.ruleName = ruleName;
+            rule.obfuscateName = ParseBool(element.GetAttribute("ob-name"), true);
+            rule.obfuscateAdd = ParseBool(element.GetAttribute("ob-add"), true);
+            rule.obfuscateRemove = ParseBool(element.GetAttribute("ob-remove"), true);
+            rule.obfuscateFire = ParseBool(element.GetAttribute("ob-fire"), true);
+            return rule;
+        }
+
+        public void LoadXmls(List<string> xmlFiles)
+        {
+            var rawAssemblySpecElements = new List<XmlElement>();
+            foreach (string file in xmlFiles)
+            {
+                LoadRawXml(file, rawAssemblySpecElements);
+            }
+            ResolveAssemblySpecs(rawAssemblySpecElements);
+        }
+
+        private void ResolveAssemblySpecs(List<XmlElement> rawAssemblySpecElements)
+        {
+            foreach (XmlElement ele in rawAssemblySpecElements)
+            {
+                string assemblyName = ele.GetAttribute("name");
+                if (string.IsNullOrEmpty(assemblyName))
+                {
+                    throw new Exception($"Invalid xml file, assembly name is empty");
+                }
+                if (_assemblyRuleSpecs.ContainsKey(assemblyName))
+                {
+                    throw new Exception($"Invalid xml file, duplicate assembly name {assemblyName}");
+                }
+                var assemblyRule = new AssemblyRuleSpec()
+                {
+                    assemblyName = assemblyName,
+                    rule = (AssemblyRule)GetOrParseRule(ele.GetAttribute("rule"), RuleType.Assembly, ele),
+                };
+                _assemblyRuleSpecs.Add(assemblyName, assemblyRule);
+            }
+        }
+
+
+        private RuleType ParseRuleType(string ruleType)
+        {
+            switch (ruleType)
+            {
+                case "assembly": return RuleType.Assembly;
+                case "type": return RuleType.Type;
+                case "method": return RuleType.Method;
+                case "field": return RuleType.Field;
+                case "property": return RuleType.Property;
+                case "event": return RuleType.Event;
+                default: throw new Exception($"Invalid rule type {ruleType}");
+            }
+        }
+
+        private ModifierType ParseModifierType(string modifierType)
+        {
+            if (string.IsNullOrEmpty(modifierType))
+            {
+                return ModifierType.All;
+            }
+            switch (modifierType)
+            {
+                case "public": return ModifierType.Public;
+                case "notPublic": return ModifierType.NotPublic;
+                case "all": return ModifierType.All;
+                default: throw new Exception($"Invalid modifier type {modifierType}");
+            }
+        }
+
+        private void LoadRawXml(string xmlFile, List<XmlElement> rawAssemblyElements)
+        {
+            Debug.Log($"ObfuscateRule::LoadXml {xmlFile}");
+            var doc = new XmlDocument();
+            doc.Load(xmlFile);
+            var root = doc.DocumentElement;
+            if (root.Name != "obfuz")
+            {
+                throw new Exception($"Invalid xml file {xmlFile}, root name should be 'obfuz'");
+            }
+            foreach (XmlNode node in root.ChildNodes)
+            {
+                if (node is not XmlElement element)
+                {
+                    continue;
+                }
+                switch (element.Name)
+                {
+                    case "rule":
+                    {
+                        string ruleName = element.GetAttribute("name");
+                        RuleType ruleType = ParseRuleType(element.GetAttribute("type"));
+                        var key = (ruleName, ruleType);
+                        if (_rawRuleElements.ContainsKey(key))
+                        {
+                            throw new Exception($"Invalid xml file {xmlFile}, duplicate rule name:{ruleName} type:{ruleType}");
+                        }
+                        _rawRuleElements.Add(key, element);
+                        break;
+                    }
+                    case "assembly":
+                    {
+                        rawAssemblyElements.Add(element);
+                        break;
+                    }
+                    default:
+                    {
+                        throw new Exception($"Invalid xml file {xmlFile}, unknown node {element.Name}");
+                    }
+                }
+            }
+        }
+
+        public bool NeedRename(ModuleDefMD mod)
+        {
+            return false;
+        }
+
+        public bool NeedRename(TypeDef typeDef)
+        {
+            return true;
+        }
+
+        public bool NeedRename(MethodDef methodDef)
+        {
+            return true;
+        }
+
+        public bool NeedRename(FieldDef fieldDef)
+        {
+            return true;
+        }
+
+        public bool NeedRename(PropertyDef propertyDef)
+        {
+            return true;
+        }
+
+        public bool NeedRename(EventDef eventDef)
+        {
+            return true;
+        }
+
+        public bool NeedRename(ParamDef paramDef)
+        {
+            return true;
+        }
+    }
+}

Editor/Obfuscator.cs

@@ -17,13 +17,14 @@ namespace Obfuz
         public class Options
         {
             public List<string> AssemblySearchDirs;
-            public List<string> ObfuscatedAssemblyNames;
+            public List<string> ObfuscationRuleFiles;
             public string mappingXmlPath;
             public string outputDir;
         }
 
         private readonly Options _options;
         private readonly AssemblyCache _assemblyCache;
+        private readonly ObfuscateRuleConfig _obfuscateRuleConfig;
 
         private readonly List<ObfuzAssemblyInfo> _obfuzAssemblies = new List<ObfuzAssemblyInfo>();
 
@@ -31,11 +32,15 @@ namespace Obfuz
         private readonly INameMaker _nameMaker;
         private readonly SymbolRename _symbolRename;
 
+        public IList<string> ObfuscatedAssemblyNames => _obfuzAssemblies.Select(x => x.name).ToList();
+
         public Obfuscator(Options options)
         {
             _options = options;
             _assemblyCache = new AssemblyCache(new PathAssemblyResolver(options.AssemblySearchDirs.ToArray()));
-            _renamePolicy = new CombineRenamePolicy(new SystemRenamePolicy(), new UnityRenamePolicy(), new XmlConfigRenamePolicy());
+            _obfuscateRuleConfig = new ObfuscateRuleConfig();
+            _obfuscateRuleConfig.LoadXmls(options.ObfuscationRuleFiles);
+            _renamePolicy = new CombineRenamePolicy(new SystemRenamePolicy(), new UnityRenamePolicy(), _obfuscateRuleConfig);
             //_nameMaker = new TestNameMaker();
             _nameMaker = NameMakerFactory.CreateNameMakerBaseASCIICharSet();
 
@@ -60,9 +65,14 @@ namespace Obfuz
 
         private void LoadAssemblies()
         {
-            foreach (string assName in _options.ObfuscatedAssemblyNames)
+            foreach (string assName in _obfuscateRuleConfig.ObfuscatedAssemblyNames)
             {
-                ModuleDefMD mod = _assemblyCache.LoadModule(assName);
+                ModuleDefMD mod = _assemblyCache.TryLoadModule(assName);
+                if (mod == null)
+                {
+                    Debug.Log($"assembly: {assName} not found! ignore.");
+                    continue;
+                }
                 var obfuzAsm = new ObfuzAssemblyInfo
                 {
                     name = assName,

Editor/Obfuz.Editor.asmdef

@@ -1,9 +1,7 @@
 {
     "name": "Obfuz",
     "rootNamespace": "",
-    "references": [
+    "references": [],
-        "GUID:167b4b7f91c16bb4183f7298af665076"
-    ],
     "includePlatforms": [
         "Editor"
     ],
@@ -13,6 +11,12 @@
     "precompiledReferences": [],
     "autoReferenced": true,
     "defineConstraints": [],
-    "versionDefines": [],
+    "versionDefines": [
+        {
+            "name": "com.code-philosophy.hybridclr",
+            "expression": "",
+            "define": "USE_HYBRIDCLR"
+        }
+    ],
     "noEngineReferences": false
 }

Editor/Rename/XmlConfigRenamePolicy.cs

@@ -1,37 +0,0 @@
-using dnlib.DotNet;
-
-namespace Obfuz.Rename
-{
-    public class XmlConfigRenamePolicy : RenamePolicyBase
-    {
-        public override bool NeedRename(ModuleDefMD mod)
-        {
-            return false;
-        }
-
-        public override bool NeedRename(TypeDef typeDef)
-        {
-            return true;
-        }
-
-        public override bool NeedRename(MethodDef methodDef)
-        {
-            return true;
-        }
-
-        public override bool NeedRename(FieldDef fieldDef)
-        {
-            return true;
-        }
-
-        public override bool NeedRename(PropertyDef propertyDef)
-        {
-            return true;
-        }
-
-        public override bool NeedRename(EventDef eventDef)
-        {
-            return true;
-        }
-    }
-}

Editor/Settings/ObfuzSettingProvider.cs

@@ -29,7 +29,8 @@ namespace Obfuz
 
         private SerializedObject _serializedObject;
         private SerializedProperty _enable;
-        private SerializedProperty _obfuscatedAssemblyNames;
+        private SerializedProperty _aotRuleFiles;
+        private SerializedProperty _hotUpdateRuleFiles;
 
         public ObfuzSettingsProvider() : base("Project/Obfuz", SettingsScope.Project)
         {
@@ -47,7 +48,8 @@ namespace Obfuz
             _serializedObject?.Dispose();
             _serializedObject = new SerializedObject(setting);
             _enable = _serializedObject.FindProperty("enable");
-            _obfuscatedAssemblyNames = _serializedObject.FindProperty("obfuscatedAssemblyNames");
+            _aotRuleFiles = _serializedObject.FindProperty("aotRuleFiles");
+            _hotUpdateRuleFiles = _serializedObject.FindProperty("hotUpdateRuleFiles");
         }
 
         private void OnEditorFocused()
@@ -68,7 +70,8 @@ namespace Obfuz
                 EditorGUI.BeginChangeCheck();
 
                 EditorGUILayout.PropertyField(_enable);
-                EditorGUILayout.PropertyField(_obfuscatedAssemblyNames);
+                EditorGUILayout.PropertyField(_aotRuleFiles);
+                EditorGUILayout.PropertyField(_hotUpdateRuleFiles);
 
                 if (EditorGUI.EndChangeCheck())
                 {

Editor/Settings/ObfuzSettings.cs

@@ -11,8 +11,11 @@ namespace Obfuz
         [Tooltip("enable Obfuz")]
         public bool enable = true;
 
-        [Tooltip("obfuscated assembly names(without .dll suffix)")]
+        [Tooltip("obfuscation rule files for aot assemblies")]
-        public string[] obfuscatedAssemblyNames;
+        public string[] aotRuleFiles;
+
+        [Tooltip("obfuscation rule files for hot update assemblies")]
+        public string[] hotUpdateRuleFiles;
 
         public string ObfuzRootDir => $"Library/Obfuz";