723 lines
27 KiB
C#
723 lines
27 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 UnityEngine;
|
|
|
|
namespace Obfuz.ObfusPasses.ConstEncrypt
|
|
{
|
|
public class ConfigurableEncryptPolicy : EncryptPolicyBase
|
|
{
|
|
private readonly List<string> _toObfuscatedAssemblyNames;
|
|
|
|
class NumberRange<T> where T : struct
|
|
{
|
|
public readonly T? min;
|
|
public readonly T? max;
|
|
|
|
public NumberRange(T? min, T? max)
|
|
{
|
|
this.min = min;
|
|
this.max = max;
|
|
}
|
|
}
|
|
|
|
class ObfuscationRule
|
|
{
|
|
public bool? disableEncrypt;
|
|
public bool? encryptInt;
|
|
public bool? encryptLong;
|
|
public bool? encryptFloat;
|
|
public bool? encryptDouble;
|
|
public bool? encryptArray;
|
|
public bool? encryptString;
|
|
|
|
public bool? encryptConstInLoop;
|
|
public bool? encryptStringInLoop;
|
|
|
|
public bool? cacheConstInLoop;
|
|
public bool? cacheConstNotInLoop;
|
|
public bool? cacheStringInLoop;
|
|
public bool? cacheStringNotInLoop;
|
|
|
|
public HashSet<int> notEncryptInts = new HashSet<int>();
|
|
public HashSet<long> notEncryptLongs = new HashSet<long>();
|
|
public HashSet<string> notEncryptStrings = new HashSet<string>();
|
|
public List<NumberRange<int>> notEncryptIntRanges = new List<NumberRange<int>>();
|
|
public List<NumberRange<long>> notEncryptLongRanges = new List<NumberRange<long>>();
|
|
public List<NumberRange<float>> notEncryptFloatRanges = new List<NumberRange<float>>();
|
|
public List<NumberRange<double>> notEncryptDoubleRanges = new List<NumberRange<double>>();
|
|
public List<NumberRange<int>> notEncryptArrayLengthRanges = new List<NumberRange<int>>();
|
|
public List<NumberRange<int>> notEncryptStringLengthRanges = new List<NumberRange<int>>();
|
|
|
|
public void InheritParent(ObfuscationRule parentRule)
|
|
{
|
|
if (disableEncrypt == null)
|
|
disableEncrypt = parentRule.disableEncrypt;
|
|
if (encryptInt == null)
|
|
encryptInt = parentRule.encryptInt;
|
|
if (encryptLong == null)
|
|
encryptLong = parentRule.encryptLong;
|
|
if (encryptFloat == null)
|
|
encryptFloat = parentRule.encryptFloat;
|
|
if (encryptDouble == null)
|
|
encryptDouble = parentRule.encryptDouble;
|
|
if (encryptArray == null)
|
|
encryptArray = parentRule.encryptArray;
|
|
if (encryptString == null)
|
|
encryptString = parentRule.encryptString;
|
|
|
|
if (encryptConstInLoop == null)
|
|
encryptConstInLoop = parentRule.encryptConstInLoop;
|
|
if (encryptStringInLoop == null)
|
|
encryptStringInLoop = parentRule.encryptStringInLoop;
|
|
|
|
if (cacheConstInLoop == null)
|
|
cacheConstInLoop = parentRule.cacheConstInLoop;
|
|
if (cacheConstNotInLoop == null)
|
|
cacheConstNotInLoop = parentRule.cacheConstNotInLoop;
|
|
if (cacheStringInLoop == null)
|
|
cacheStringInLoop = parentRule.cacheStringInLoop;
|
|
if (cacheStringNotInLoop == null)
|
|
cacheStringNotInLoop = parentRule.cacheStringNotInLoop;
|
|
|
|
notEncryptInts.AddRange(parentRule.notEncryptInts);
|
|
notEncryptLongs.AddRange(parentRule.notEncryptLongs);
|
|
notEncryptStrings.AddRange(parentRule.notEncryptStrings);
|
|
notEncryptIntRanges.AddRange(parentRule.notEncryptIntRanges);
|
|
notEncryptLongRanges.AddRange(parentRule.notEncryptLongRanges);
|
|
notEncryptFloatRanges.AddRange(parentRule.notEncryptFloatRanges);
|
|
notEncryptDoubleRanges.AddRange(parentRule.notEncryptDoubleRanges);
|
|
notEncryptArrayLengthRanges.AddRange(parentRule.notEncryptArrayLengthRanges);
|
|
notEncryptStringLengthRanges.AddRange(parentRule.notEncryptStringLengthRanges);
|
|
}
|
|
}
|
|
|
|
class MethodSpec
|
|
{
|
|
public string name;
|
|
public NameMatcher nameMatcher;
|
|
public ObfuscationRule rule;
|
|
}
|
|
|
|
class TypeSpec
|
|
{
|
|
public string name;
|
|
public NameMatcher nameMatcher;
|
|
public ObfuscationRule rule;
|
|
public List<MethodSpec> methodSpecs = new List<MethodSpec>();
|
|
}
|
|
|
|
class AssemblySpec
|
|
{
|
|
public string name;
|
|
public ObfuscationRule rule;
|
|
public List<TypeSpec> typeSpecs = new List<TypeSpec>();
|
|
}
|
|
|
|
private static readonly ObfuscationRule s_default = new ObfuscationRule()
|
|
{
|
|
disableEncrypt = false,
|
|
encryptInt = true,
|
|
encryptLong = true,
|
|
encryptFloat = true,
|
|
encryptDouble = true,
|
|
encryptArray = true,
|
|
encryptString = true,
|
|
encryptConstInLoop = true,
|
|
encryptStringInLoop = true,
|
|
cacheConstInLoop = true,
|
|
cacheConstNotInLoop = false,
|
|
cacheStringInLoop = true,
|
|
cacheStringNotInLoop = true,
|
|
};
|
|
|
|
private ObfuscationRule _global;
|
|
private readonly Dictionary<string, AssemblySpec> _assemblySpecs = new Dictionary<string, AssemblySpec>();
|
|
private readonly Dictionary<MethodDef, ObfuscationRule> _methodRuleCache = new Dictionary<MethodDef, ObfuscationRule>();
|
|
|
|
public ConfigurableEncryptPolicy(List<string> toObfuscatedAssemblyNames, string xmlConfigFile)
|
|
{
|
|
_toObfuscatedAssemblyNames = toObfuscatedAssemblyNames;
|
|
LoadConfig(xmlConfigFile);
|
|
InheritParentRules();
|
|
}
|
|
|
|
private void LoadConfig(string configFile)
|
|
{
|
|
if (string.IsNullOrEmpty(configFile))
|
|
{
|
|
return;
|
|
}
|
|
Debug.Log($"ConfigurableObfuscationPolicy::LoadConfig {configFile}");
|
|
var doc = new XmlDocument();
|
|
doc.Load(configFile);
|
|
var root = doc.DocumentElement;
|
|
if (root.Name != "obfuz")
|
|
{
|
|
throw new Exception($"Invalid xml file {configFile}, root name should be 'obfuz'");
|
|
}
|
|
foreach (XmlNode node in root.ChildNodes)
|
|
{
|
|
if (!(node is XmlElement ele))
|
|
{
|
|
continue;
|
|
}
|
|
switch (ele.Name)
|
|
{
|
|
case "global": _global = ParseObfuscationRule(ele, true); break;
|
|
case "assembly":
|
|
{
|
|
AssemblySpec assSpec = ParseAssembly(ele);
|
|
string name = assSpec.name;
|
|
if (!_toObfuscatedAssemblyNames.Contains(name))
|
|
{
|
|
throw new Exception($"Invalid xml file {configFile}, assembly name {name} is in toObfuscatedAssemblyNames");
|
|
}
|
|
if (_assemblySpecs.ContainsKey(name))
|
|
{
|
|
throw new Exception($"Invalid xml file {configFile}, assembly name {name} is duplicated");
|
|
}
|
|
_assemblySpecs.Add(name, assSpec);
|
|
break;
|
|
}
|
|
default: throw new Exception($"Invalid xml file {configFile}, unknown node {ele.Name}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void InheritParentRules()
|
|
{
|
|
if (_global == null)
|
|
{
|
|
_global = s_default;
|
|
}
|
|
else
|
|
{
|
|
_global.InheritParent(s_default);
|
|
}
|
|
foreach (AssemblySpec assSpec in _assemblySpecs.Values)
|
|
{
|
|
assSpec.rule.InheritParent(_global);
|
|
foreach (TypeSpec typeSpec in assSpec.typeSpecs)
|
|
{
|
|
typeSpec.rule.InheritParent(assSpec.rule);
|
|
foreach (MethodSpec methodSpec in typeSpec.methodSpecs)
|
|
{
|
|
methodSpec.rule.InheritParent(typeSpec.rule);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool ParseBool(string str)
|
|
{
|
|
switch (str.ToLowerInvariant())
|
|
{
|
|
case "1":
|
|
case "true": return true;
|
|
case "0":
|
|
case "false": return false;
|
|
default: throw new Exception($"Invalid bool value {str}");
|
|
}
|
|
}
|
|
|
|
private int? ParseNullableInt(string str)
|
|
{
|
|
if (string.IsNullOrEmpty(str))
|
|
{
|
|
return null;
|
|
}
|
|
return int.Parse(str);
|
|
}
|
|
|
|
private long? ParseNullableLong(string str)
|
|
{
|
|
if (string.IsNullOrEmpty(str))
|
|
{
|
|
return null;
|
|
}
|
|
return long.Parse(str);
|
|
}
|
|
|
|
private float? ParseNullableFloat(string str)
|
|
{
|
|
if (string.IsNullOrEmpty(str))
|
|
{
|
|
return null;
|
|
}
|
|
return float.Parse(str);
|
|
}
|
|
|
|
private double? ParseNullableDouble(string str)
|
|
{
|
|
if (string.IsNullOrEmpty(str))
|
|
{
|
|
return null;
|
|
}
|
|
return double.Parse(str);
|
|
}
|
|
|
|
private ObfuscationRule ParseObfuscationRule(XmlElement ele, bool parseWhitelist)
|
|
{
|
|
var rule = new ObfuscationRule();
|
|
if (ele.HasAttribute("disableEncrypt"))
|
|
{
|
|
rule.disableEncrypt = ParseBool(ele.GetAttribute("disableEncrypt"));
|
|
}
|
|
if (ele.HasAttribute("encryptInt"))
|
|
{
|
|
rule.encryptInt = ParseBool(ele.GetAttribute("encryptInt"));
|
|
}
|
|
if (ele.HasAttribute("encryptLong"))
|
|
{
|
|
rule.encryptLong = ParseBool(ele.GetAttribute("encryptLong"));
|
|
}
|
|
if (ele.HasAttribute("encryptFloat"))
|
|
{
|
|
rule.encryptFloat = ParseBool(ele.GetAttribute("encryptFloat"));
|
|
}
|
|
if (ele.HasAttribute("encryptDouble"))
|
|
{
|
|
rule.encryptDouble = ParseBool(ele.GetAttribute("encryptDouble"));
|
|
}
|
|
if (ele.HasAttribute("encryptBytes"))
|
|
{
|
|
rule.encryptArray = ParseBool(ele.GetAttribute("encryptArray"));
|
|
}
|
|
if (ele.HasAttribute("encryptString"))
|
|
{
|
|
rule.encryptString = ParseBool(ele.GetAttribute("encryptString"));
|
|
}
|
|
|
|
if (ele.HasAttribute("encryptConstInLoop"))
|
|
{
|
|
rule.encryptConstInLoop = ParseBool(ele.GetAttribute("encryptConstInLoop"));
|
|
}
|
|
if (ele.HasAttribute("encryptStringInLoop"))
|
|
{
|
|
rule.encryptStringInLoop = ParseBool(ele.GetAttribute("encryptStringInLoop"));
|
|
}
|
|
if (ele.HasAttribute("cacheConstInLoop"))
|
|
{
|
|
rule.cacheConstInLoop = ParseBool(ele.GetAttribute("cacheConstInLoop"));
|
|
}
|
|
if (ele.HasAttribute("cacheConstNotInLoop"))
|
|
{
|
|
rule.cacheConstNotInLoop = ParseBool(ele.GetAttribute("cacheConstNotInLoop"));
|
|
}
|
|
if (ele.HasAttribute("cacheStringInLoop"))
|
|
{
|
|
rule.cacheStringInLoop = ParseBool(ele.GetAttribute("cacheStringInLoop"));
|
|
}
|
|
if (ele.HasAttribute("cacheStringNotInLoop"))
|
|
{
|
|
rule.cacheStringNotInLoop = ParseBool(ele.GetAttribute("cacheStringNotInLoop"));
|
|
}
|
|
if (parseWhitelist)
|
|
{
|
|
ParseWhitelist(ele, rule);
|
|
}
|
|
return rule;
|
|
}
|
|
|
|
private void ParseWhitelist(XmlElement ruleEle, ObfuscationRule rule)
|
|
{
|
|
foreach (XmlNode xmlNode in ruleEle.ChildNodes)
|
|
{
|
|
if (!(xmlNode is XmlElement childEle))
|
|
{
|
|
continue;
|
|
}
|
|
switch (childEle.Name)
|
|
{
|
|
case "whitelist":
|
|
{
|
|
string type = childEle.GetAttribute("type");
|
|
if (string.IsNullOrEmpty(type))
|
|
{
|
|
throw new Exception($"Invalid xml file, whitelist type is empty");
|
|
}
|
|
string value = childEle.InnerText;
|
|
switch (type)
|
|
{
|
|
case "int":
|
|
{
|
|
rule.notEncryptInts.AddRange(value.Split(",").Select(s => int.Parse(s.Trim())));
|
|
break;
|
|
}
|
|
case "long":
|
|
{
|
|
rule.notEncryptLongs.AddRange(value.Split(",").Select(s => long.Parse(s.Trim())));
|
|
break;
|
|
}
|
|
case "string":
|
|
{
|
|
rule.notEncryptStrings.AddRange(value.Split(",").Select(s => s.Trim()));
|
|
break;
|
|
}
|
|
case "int-range":
|
|
{
|
|
var parts = value.Split(",");
|
|
if (parts.Length != 2)
|
|
{
|
|
throw new Exception($"Invalid xml file, int-range {value} is invalid");
|
|
}
|
|
rule.notEncryptIntRanges.Add(new NumberRange<int>(ParseNullableInt(parts[0]), ParseNullableInt(parts[1])));
|
|
break;
|
|
}
|
|
case "long-range":
|
|
{
|
|
var parts = value.Split(",");
|
|
if (parts.Length != 2)
|
|
{
|
|
throw new Exception($"Invalid xml file, long-range {value} is invalid");
|
|
}
|
|
rule.notEncryptLongRanges.Add(new NumberRange<long>(ParseNullableLong(parts[0]), ParseNullableLong(parts[1])));
|
|
break;
|
|
}
|
|
case "float-range":
|
|
{
|
|
var parts = value.Split(",");
|
|
if (parts.Length != 2)
|
|
{
|
|
throw new Exception($"Invalid xml file, float-range {value} is invalid");
|
|
}
|
|
rule.notEncryptFloatRanges.Add(new NumberRange<float>(ParseNullableFloat(parts[0]), ParseNullableFloat(parts[1])));
|
|
break;
|
|
}
|
|
case "double-range":
|
|
{
|
|
var parts = value.Split(",");
|
|
if (parts.Length != 2)
|
|
{
|
|
throw new Exception($"Invalid xml file, double-range {value} is invalid");
|
|
}
|
|
rule.notEncryptDoubleRanges.Add(new NumberRange<double>(ParseNullableDouble(parts[0]), ParseNullableDouble(parts[1])));
|
|
break;
|
|
}
|
|
case "string-length-range":
|
|
{
|
|
var parts = value.Split(",");
|
|
if (parts.Length != 2)
|
|
{
|
|
throw new Exception($"Invalid xml file, string-length-range {value} is invalid");
|
|
}
|
|
rule.notEncryptStringLengthRanges.Add(new NumberRange<int>(ParseNullableInt(parts[0]), ParseNullableInt(parts[1])));
|
|
break;
|
|
}
|
|
case "array-length-range":
|
|
{
|
|
var parts = value.Split(",");
|
|
if (parts.Length != 2)
|
|
{
|
|
throw new Exception($"Invalid xml file, array-length-range {value} is invalid");
|
|
}
|
|
rule.notEncryptArrayLengthRanges.Add(new NumberRange<int>(ParseNullableInt(parts[0]), ParseNullableInt(parts[1])));
|
|
break;
|
|
}
|
|
default: throw new Exception($"Invalid xml file, unknown whitelist type {type} in {childEle.Name} node");
|
|
}
|
|
break;
|
|
}
|
|
default: throw new Exception($"Invalid xml file, unknown node {childEle.Name}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private AssemblySpec ParseAssembly(XmlElement element)
|
|
{
|
|
var assemblySpec = new AssemblySpec();
|
|
assemblySpec.name = element.GetAttribute("name");
|
|
if (string.IsNullOrEmpty(assemblySpec.name))
|
|
{
|
|
throw new Exception($"Invalid xml file, assembly name is empty");
|
|
}
|
|
assemblySpec.rule = ParseObfuscationRule(element, false);
|
|
foreach (XmlNode node in element.ChildNodes)
|
|
{
|
|
if (!(node is XmlElement ele))
|
|
{
|
|
continue;
|
|
}
|
|
switch (ele.Name)
|
|
{
|
|
case "type":
|
|
assemblySpec.typeSpecs.Add(ParseType(ele));
|
|
break;
|
|
default:
|
|
throw new Exception($"Invalid xml file, unknown node {ele.Name}");
|
|
}
|
|
}
|
|
return assemblySpec;
|
|
}
|
|
|
|
private TypeSpec ParseType(XmlElement element)
|
|
{
|
|
var typeSpec = new TypeSpec();
|
|
typeSpec.name = element.GetAttribute("name");
|
|
typeSpec.nameMatcher = new NameMatcher(typeSpec.name);
|
|
if (string.IsNullOrEmpty(typeSpec.name))
|
|
{
|
|
throw new Exception($"Invalid xml file, type name is empty");
|
|
}
|
|
typeSpec.rule = ParseObfuscationRule(element, false);
|
|
foreach (XmlNode node in element.ChildNodes)
|
|
{
|
|
if (!(node is XmlElement ele))
|
|
{
|
|
continue;
|
|
}
|
|
switch (ele.Name)
|
|
{
|
|
case "method":
|
|
typeSpec.methodSpecs.Add(ParseMethod(ele));
|
|
break;
|
|
default:
|
|
throw new Exception($"Invalid xml file, unknown node {ele.Name}");
|
|
}
|
|
}
|
|
return typeSpec;
|
|
}
|
|
|
|
private MethodSpec ParseMethod(XmlElement element)
|
|
{
|
|
var methodSpec = new MethodSpec();
|
|
methodSpec.name = element.GetAttribute("name");
|
|
methodSpec.nameMatcher = new NameMatcher(methodSpec.name);
|
|
if (string.IsNullOrEmpty(methodSpec.name))
|
|
{
|
|
throw new Exception($"Invalid xml file, method name is empty");
|
|
}
|
|
methodSpec.rule = ParseObfuscationRule(element, false);
|
|
return methodSpec;
|
|
}
|
|
|
|
|
|
private ObfuscationRule ComputeMethodObfuscationRule(MethodDef method)
|
|
{
|
|
var assemblyName = method.DeclaringType.Module.Assembly.Name;
|
|
if (!_assemblySpecs.TryGetValue(assemblyName, out var assSpec))
|
|
{
|
|
return _global;
|
|
}
|
|
string declaringTypeName = method.DeclaringType.FullName;
|
|
foreach (var typeSpec in assSpec.typeSpecs)
|
|
{
|
|
if (typeSpec.nameMatcher.IsMatch(declaringTypeName))
|
|
{
|
|
foreach (var methodSpec in typeSpec.methodSpecs)
|
|
{
|
|
if (methodSpec.nameMatcher.IsMatch(method.Name))
|
|
{
|
|
return methodSpec.rule;
|
|
}
|
|
}
|
|
return typeSpec.rule;
|
|
}
|
|
}
|
|
return assSpec.rule;
|
|
}
|
|
|
|
private ObfuscationRule GetMethodObfuscationRule(MethodDef method)
|
|
{
|
|
if (!_methodRuleCache.TryGetValue(method, out var rule))
|
|
{
|
|
rule = ComputeMethodObfuscationRule(method);
|
|
_methodRuleCache[method] = rule;
|
|
}
|
|
return rule;
|
|
}
|
|
|
|
public override bool NeedObfuscateMethod(MethodDef method)
|
|
{
|
|
ObfuscationRule rule = GetMethodObfuscationRule(method);
|
|
return rule.disableEncrypt != true;
|
|
}
|
|
|
|
public override ConstCachePolicy GetMethodConstCachePolicy(MethodDef method)
|
|
{
|
|
ObfuscationRule rule = GetMethodObfuscationRule(method);
|
|
return new ConstCachePolicy
|
|
{
|
|
cacheConstInLoop = rule.cacheConstInLoop.Value,
|
|
cacheConstNotInLoop = rule.cacheConstNotInLoop.Value,
|
|
cacheStringInLoop = rule.cacheStringInLoop.Value,
|
|
cacheStringNotInLoop = rule.cacheStringNotInLoop.Value,
|
|
};
|
|
}
|
|
|
|
public override bool NeedObfuscateInt(MethodDef method, bool currentInLoop, int value)
|
|
{
|
|
ObfuscationRule rule = GetMethodObfuscationRule(method);
|
|
if (rule.encryptInt == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentInLoop && rule.encryptConstInLoop == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (rule.notEncryptInts.Contains(value))
|
|
{
|
|
return false;
|
|
}
|
|
foreach (var range in rule.notEncryptIntRanges)
|
|
{
|
|
if (range.min != null && value < range.min)
|
|
{
|
|
continue;
|
|
}
|
|
if (range.max != null && value > range.max)
|
|
{
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool NeedObfuscateLong(MethodDef method, bool currentInLoop, long value)
|
|
{
|
|
ObfuscationRule rule = GetMethodObfuscationRule(method);
|
|
if (rule.encryptLong == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentInLoop && rule.encryptConstInLoop == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (rule.notEncryptLongs.Contains(value))
|
|
{
|
|
return false;
|
|
}
|
|
foreach (var range in rule.notEncryptLongRanges)
|
|
{
|
|
if (range.min != null && value < range.min)
|
|
{
|
|
continue;
|
|
}
|
|
if (range.max != null && value > range.max)
|
|
{
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool NeedObfuscateFloat(MethodDef method, bool currentInLoop, float value)
|
|
{
|
|
ObfuscationRule rule = GetMethodObfuscationRule(method);
|
|
if (rule.encryptFloat == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentInLoop && rule.encryptConstInLoop == false)
|
|
{
|
|
return false;
|
|
}
|
|
foreach (var range in rule.notEncryptFloatRanges)
|
|
{
|
|
if (range.min != null && value < range.min)
|
|
{
|
|
continue;
|
|
}
|
|
if (range.max != null && value > range.max)
|
|
{
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool NeedObfuscateDouble(MethodDef method, bool currentInLoop, double value)
|
|
{
|
|
ObfuscationRule rule = GetMethodObfuscationRule(method);
|
|
if (rule.encryptDouble == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentInLoop && rule.encryptConstInLoop == false)
|
|
{
|
|
return false;
|
|
}
|
|
foreach (var range in rule.notEncryptDoubleRanges)
|
|
{
|
|
if (range.min != null && value < range.min)
|
|
{
|
|
continue;
|
|
}
|
|
if (range.max != null && value > range.max)
|
|
{
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool NeedObfuscateString(MethodDef method, bool currentInLoop, string value)
|
|
{
|
|
ObfuscationRule rule = GetMethodObfuscationRule(method);
|
|
if (rule.encryptString == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentInLoop && rule.encryptConstInLoop == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (rule.notEncryptStrings.Contains(value))
|
|
{
|
|
return false;
|
|
}
|
|
foreach (var range in rule.notEncryptStringLengthRanges)
|
|
{
|
|
if (range.min != null && value.Length < range.min)
|
|
{
|
|
continue;
|
|
}
|
|
if (range.max != null && value.Length > range.max)
|
|
{
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool NeedObfuscateArray(MethodDef method, bool currentInLoop, byte[] array)
|
|
{
|
|
ObfuscationRule rule = GetMethodObfuscationRule(method);
|
|
if (rule.encryptArray == false)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentInLoop && rule.encryptConstInLoop == false)
|
|
{
|
|
return false;
|
|
}
|
|
foreach (var range in rule.notEncryptArrayLengthRanges)
|
|
{
|
|
if (range.min != null && array.Length < range.min)
|
|
{
|
|
continue;
|
|
}
|
|
if (range.max != null && array.Length > range.max)
|
|
{
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|