644 lines
23 KiB
C#
644 lines
23 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|