896 lines
34 KiB
C#
896 lines
34 KiB
C#
using dnlib.DotNet;
|
|
using Obfuz.Utils;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Xml;
|
|
using System.Xml.Linq;
|
|
using UnityEngine;
|
|
|
|
namespace Obfuz.ObfusPasses.SymbolObfus.Policies
|
|
{
|
|
|
|
public class ConfigurableRenamePolicy : ObfuscationPolicyBase
|
|
{
|
|
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
|
|
{
|
|
Private = 0,
|
|
Protected = 1,
|
|
Public = 2,
|
|
}
|
|
|
|
interface IRule
|
|
{
|
|
|
|
}
|
|
|
|
class MethodRuleSpec
|
|
{
|
|
public NameMatcher nameMatcher;
|
|
public ModifierType modifierType;
|
|
public MethodRule rule;
|
|
}
|
|
|
|
class MethodRule : IRule
|
|
{
|
|
public string ruleName;
|
|
public bool obfuscateName;
|
|
public bool obfuscateParam;
|
|
public bool obfuscateBody;
|
|
}
|
|
|
|
class FieldRuleSpec
|
|
{
|
|
public NameMatcher nameMatcher;
|
|
public ModifierType modifierType;
|
|
public FieldRule rule;
|
|
}
|
|
|
|
class FieldRule : IRule
|
|
{
|
|
public string ruleName;
|
|
public bool obfuscateName;
|
|
}
|
|
|
|
class PropertyRuleSpec
|
|
{
|
|
public NameMatcher nameMatcher;
|
|
public PropertyRule rule;
|
|
}
|
|
|
|
class PropertyRule : IRule
|
|
{
|
|
public string ruleName;
|
|
public bool obfuscateName;
|
|
public MethodRuleSpec getter;
|
|
public MethodRuleSpec setter;
|
|
}
|
|
|
|
class EventRuleSpec
|
|
{
|
|
public NameMatcher nameMatcher;
|
|
public EventRule rule;
|
|
}
|
|
|
|
class EventRule : IRule
|
|
{
|
|
public string ruleName;
|
|
public bool obfuscateName;
|
|
public MethodRuleSpec add;
|
|
public MethodRuleSpec remove;
|
|
public MethodRuleSpec fire;
|
|
}
|
|
|
|
class TypeRuleSpec
|
|
{
|
|
public NameMatcher nameMatcher;
|
|
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>();
|
|
|
|
|
|
private static readonly MethodRule s_noneMethodRule = new MethodRule
|
|
{
|
|
ruleName = "none",
|
|
obfuscateName = false,
|
|
obfuscateParam = false,
|
|
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",
|
|
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 = new List<TypeRuleSpec> { new TypeRuleSpec { rule = s_noneTypeRule } },
|
|
};
|
|
|
|
//static ObfuscateRuleConfig()
|
|
//{
|
|
// 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 == "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 ParseBoolNoneOrFalse(string str)
|
|
{
|
|
if (string.IsNullOrEmpty(str))
|
|
{
|
|
return true;
|
|
}
|
|
switch (str.ToLowerInvariant())
|
|
{
|
|
case "1":
|
|
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}");
|
|
}
|
|
}
|
|
|
|
private AssemblyRule ParseAssemblyRule(string ruleName, XmlElement element)
|
|
{
|
|
var rule = new AssemblyRule();
|
|
rule.ruleName = ruleName;
|
|
rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob-name"));
|
|
rule.typeRuleSpecs = new List<TypeRuleSpec>();
|
|
foreach (XmlNode node in element.ChildNodes)
|
|
{
|
|
if (!(node is XmlElement childElement))
|
|
{
|
|
continue;
|
|
}
|
|
if (childElement.Name != "type")
|
|
{
|
|
throw new Exception($"Invalid xml file, unknown node {childElement.Name}");
|
|
}
|
|
var typeRuleSpec = new TypeRuleSpec();
|
|
typeRuleSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
|
|
typeRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifier"));
|
|
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 = ParseBoolNoneOrFalse(element.GetAttribute("ob-name"));
|
|
rule.obfuscateNamespace = ParseBoolNoneOrFalse(element.GetAttribute("ob-namespace"));
|
|
//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 XmlElement childElement))
|
|
{
|
|
continue;
|
|
}
|
|
switch (childElement.Name)
|
|
{
|
|
//case "nesttype":
|
|
//{
|
|
// var typeRuleSpec = new TypeRuleSpec();
|
|
// typeRuleSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
|
|
// typeRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifier"));
|
|
// typeRuleSpec.rule = (TypeRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Type, childElement);
|
|
// rule.nestTypeRuleSpecs.Add(typeRuleSpec);
|
|
// break;
|
|
//}
|
|
case "field":
|
|
{
|
|
var fieldRuleSpec = new FieldRuleSpec();
|
|
fieldRuleSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
|
|
fieldRuleSpec.modifierType = ParseModifierType(childElement.GetAttribute("modifier"));
|
|
fieldRuleSpec.rule = (FieldRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Field, childElement);
|
|
rule.fieldRuleSpecs.Add(fieldRuleSpec);
|
|
break;
|
|
}
|
|
case "method":
|
|
{
|
|
rule.methodRuleSpecs.Add(ParseMethodRuleSpec(childElement));
|
|
break;
|
|
}
|
|
case "property":
|
|
{
|
|
var propertyRulerSpec = new PropertyRuleSpec();
|
|
propertyRulerSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
|
|
propertyRulerSpec.rule = (PropertyRule)GetOrParseRule(childElement.GetAttribute("rule"), RuleType.Property, childElement);
|
|
rule.propertyRuleSpecs.Add(propertyRulerSpec);
|
|
break;
|
|
}
|
|
case "event":
|
|
{
|
|
var eventRuleSpec = new EventRuleSpec();
|
|
eventRuleSpec.nameMatcher = new NameMatcher(childElement.GetAttribute("name"));
|
|
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 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 = ParseBoolNoneOrFalse(element.GetAttribute("ob-name"));
|
|
rule.obfuscateParam = ParseBoolNoneOrFalse(element.GetAttribute("ob-param"));
|
|
rule.obfuscateBody = ParseBoolNoneOrFalse(element.GetAttribute("ob-body"));
|
|
return rule;
|
|
}
|
|
|
|
private FieldRule ParseFieldRule(string ruleName, XmlElement element)
|
|
{
|
|
var rule = new FieldRule();
|
|
rule.ruleName = ruleName;
|
|
rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob-name"));
|
|
return rule;
|
|
}
|
|
|
|
private PropertyRule ParsePropertyRule(string ruleName, XmlElement element)
|
|
{
|
|
var rule = new PropertyRule();
|
|
rule.ruleName = ruleName;
|
|
rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob-name"));
|
|
|
|
foreach (XmlNode node in element.ChildNodes)
|
|
{
|
|
if (!(node is 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;
|
|
}
|
|
|
|
private EventRule ParseEventRule(string ruleName, XmlElement element)
|
|
{
|
|
var rule = new EventRule();
|
|
rule.ruleName = ruleName;
|
|
rule.obfuscateName = ParseBoolNoneOrFalse(element.GetAttribute("ob-name"));
|
|
|
|
foreach (XmlNode node in element.ChildNodes)
|
|
{
|
|
if (!(node is 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;
|
|
}
|
|
|
|
private 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 (!_obfuscationAssemblyNames.Contains(assemblyName))
|
|
{
|
|
throw new Exception($"unknown assembly name:{assemblyName}, not in ObfuzSettings.obfuscationAssemblyNames");
|
|
}
|
|
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.Private;
|
|
}
|
|
switch (modifierType)
|
|
{
|
|
case "public": return ModifierType.Public;
|
|
case "protected": return ModifierType.Protected;
|
|
case "private": return ModifierType.Private;
|
|
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();
|
|
//var nsManager = new XmlNamespaceManager(doc.NameTable);
|
|
//nsManager.AddNamespace("ob", "https://github.com/focus-creative-games/Obfuz"); // 绑定前缀到 URI
|
|
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 XmlElement element))
|
|
{
|
|
continue;
|
|
}
|
|
switch (element.Name)
|
|
{
|
|
case "rules":
|
|
{
|
|
ParseRules(xmlFile, element);
|
|
break;
|
|
}
|
|
case "assembly":
|
|
{
|
|
rawAssemblyElements.Add(element);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
throw new Exception($"Invalid xml file {xmlFile}, unknown node {element.Name}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParseRules(string xmlFile, XmlElement rulesNode)
|
|
{
|
|
foreach (XmlNode node in rulesNode)
|
|
{
|
|
if (!(node is XmlElement ruleEle))
|
|
{
|
|
continue;
|
|
}
|
|
string ruleName = ruleEle.GetAttribute("name");
|
|
string ruleTypeName = ruleEle.Name;
|
|
RuleType ruleType = ParseRuleType(ruleTypeName);
|
|
var key = (ruleName, ruleType);
|
|
if (_rawRuleElements.ContainsKey(key))
|
|
{
|
|
throw new Exception($"Invalid xml file {xmlFile}, duplicate rule name:{ruleName} type:{ruleType}");
|
|
}
|
|
_rawRuleElements.Add(key, ruleEle);
|
|
}
|
|
|
|
}
|
|
|
|
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 readonly HashSet<string> _obfuscationAssemblyNames;
|
|
|
|
public ConfigurableRenamePolicy(List<string> obfuscationAssemblyNames, List<string> xmlFiles)
|
|
{
|
|
_obfuscationAssemblyNames = new HashSet<string>(obfuscationAssemblyNames);
|
|
LoadXmls(xmlFiles);
|
|
}
|
|
|
|
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) || assemblyRuleSpec.rule == null)
|
|
{
|
|
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 != null && !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 eventSpec in typeRule.rule.eventRuleSpecs)
|
|
{
|
|
if (eventSpec.nameMatcher != null && !eventSpec.nameMatcher.IsMatch(eventDef.Name))
|
|
{
|
|
continue;
|
|
}
|
|
EventRule eventRule = eventSpec.rule;
|
|
if (!eventRule.obfuscateName)
|
|
{
|
|
cache.notObfuscatedEvents.Add(eventDef);
|
|
}
|
|
if (eventDef.AddMethod != null && eventRule.add != null && MatchModifier(eventRule.add.modifierType, eventDef.AddMethod))
|
|
{
|
|
totalMethodSpecFromPropertyAndEvents.Add((eventDef.AddMethod,eventRule.add));
|
|
}
|
|
if (eventDef.RemoveMethod != null && eventRule.remove != null && MatchModifier(eventRule.remove.modifierType, eventDef.RemoveMethod))
|
|
{
|
|
totalMethodSpecFromPropertyAndEvents.Add((eventDef.RemoveMethod, eventRule.remove));
|
|
}
|
|
if (eventDef.InvokeMethod != null && eventRule.fire != null && MatchModifier(eventRule.fire.modifierType, eventDef.InvokeMethod))
|
|
{
|
|
totalMethodSpecFromPropertyAndEvents.Add((eventDef.InvokeMethod, eventRule.fire));
|
|
}
|
|
}
|
|
}
|
|
foreach (var propertyDef in typeDef.Properties)
|
|
{
|
|
foreach (var propertySpec in typeRule.rule.propertyRuleSpecs)
|
|
{
|
|
if (propertySpec.nameMatcher != null && !propertySpec.nameMatcher.IsMatch(propertyDef.Name))
|
|
{
|
|
continue;
|
|
}
|
|
PropertyRule propertyRule = propertySpec.rule;
|
|
if (!propertyRule.obfuscateName)
|
|
{
|
|
cache.notObfuscatedProperties.Add(propertyDef);
|
|
}
|
|
if (propertyDef.GetMethod != null && propertyRule.getter != null && MatchModifier(propertyRule.getter.modifierType, propertyDef.GetMethod))
|
|
{
|
|
totalMethodSpecFromPropertyAndEvents.Add((propertyDef.GetMethod, propertyRule.getter));
|
|
}
|
|
if (propertyDef.SetMethod != null && propertyRule.setter != null && MatchModifier(propertyRule.setter.modifierType, propertyDef.SetMethod))
|
|
{
|
|
totalMethodSpecFromPropertyAndEvents.Add((propertyDef.SetMethod, propertyRule.setter));
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var fieldDef in typeDef.Fields)
|
|
{
|
|
foreach (var fieldRule in typeRule.rule.fieldRuleSpecs)
|
|
{
|
|
if ((fieldRule.nameMatcher == null || 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 != null && !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 override bool NeedRename(TypeDef typeDef)
|
|
{
|
|
TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
|
|
return cache.obfuscateName;
|
|
}
|
|
|
|
public override 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 override bool NeedRename(FieldDef fieldDef)
|
|
{
|
|
TypeDef typeDef = fieldDef.DeclaringType;
|
|
TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
|
|
return !cache.notObfuscatedFields.Contains(fieldDef);
|
|
}
|
|
|
|
public override bool NeedRename(PropertyDef propertyDef)
|
|
{
|
|
TypeDef typeDef = propertyDef.DeclaringType;
|
|
TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
|
|
return !cache.notObfuscatedProperties.Contains(propertyDef);
|
|
}
|
|
|
|
public override bool NeedRename(EventDef eventDef)
|
|
{
|
|
TypeDef typeDef = eventDef.DeclaringType;
|
|
TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
|
|
return !cache.notObfuscatedEvents.Contains(eventDef);
|
|
}
|
|
|
|
public override 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;
|
|
}
|
|
}
|
|
}
|