/// <summary>
/// Applies the rules to the target definition.
/// </summary>
/// <param name="context">The working context.</param>
/// <param name="target">The target definition.</param>
/// <param name="rules">The rules.</param>
/// <param name="baseSettings">The base settings.</param>
protected void ApplyRules(ConfuserContext context, ISDnlibDef target, Rules rules, ProtectionSettings baseSettings = null)
{
var ret = baseSettings == null ? new ProtectionSettings() : new ProtectionSettings(baseSettings);
foreach (var i in rules)
{
if (!(bool)i.Value.Evaluate(target))
{
continue;
}
if (!i.Key.Inherit)
{
ret.Clear();
}
FillPreset(i.Key.Preset, ret);
foreach (var prot in i.Key)
{
if (prot.Action == SettingItemAction.Add)
{
ret[protections[prot.Id]] = new Dictionary <string, string>(prot, StringComparer.OrdinalIgnoreCase);
}
else
{
ret.Remove(protections[prot.Id]);
}
}
}
ProtectionParameters.SetParameters(context, target, ret);
}
/// <summary>
/// Marks the member definition.
/// </summary>
/// <param name="member">The member definition.</param>
/// <param name="context">The working context.</param>
protected internal virtual void MarkMember(ISDnlibDef member, ConfuserContext context)
{
ModuleDef module = ((IMemberRef)member).Module;
var rules = context.Annotations.Get <Rules>(module, RulesKey);
ApplyRules(context, member, rules);
}
private void ApplyInfo(ISDnlibDef context, ProtectionSettings settings, IEnumerable <ProtectionSettingsInfo> infos, ApplyInfoType type)
{
foreach (var info in infos)
{
if (info.Condition != null && !(bool)info.Condition.Evaluate(context))
{
continue;
}
if (info.Condition == null && info.Exclude)
{
if (type == ApplyInfoType.CurrentInfoOnly ||
(type == ApplyInfoType.CurrentInfoInherits && info.ApplyToMember))
{
settings.Clear();
}
}
if (!string.IsNullOrEmpty(info.Settings))
{
if ((type == ApplyInfoType.ParentInfo && info.Condition != null && info.ApplyToMember) ||
type == ApplyInfoType.CurrentInfoOnly ||
(type == ApplyInfoType.CurrentInfoInherits && info.Condition == null && info.ApplyToMember))
{
parser.ParseProtectionString(settings, info.Settings);
}
}
}
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
if (!(definition is TypeDef) && !(definition is IMemberDef))
{
return(false);
}
var ns = "^" + Arguments[0].Evaluate(definition).ToString() + "$";
var type = definition as TypeDef;
if (type == null)
{
type = ((IMemberDef)definition).DeclaringType;
}
if (type == null)
{
return(false);
}
while (type.IsNested)
{
type = type.DeclaringType;
}
return(type != null && Regex.IsMatch(type.Namespace ?? "", ns));
}
private static bool ShouldExclude(TypeDef type, ISDnlibDef def)
{
CustomAttribute attr;
if (def.CustomAttributes.IsDefined(JsonProperty))
{
attr = def.CustomAttributes.Find(JsonProperty);
if (attr.HasConstructorArguments || attr.GetProperty("PropertyName") != null)
{
return(false);
}
}
attr = GetJsonContainerAttribute(type);
if (attr == null || attr.TypeFullName != JsonObject)
{
return(false);
}
if (def.CustomAttributes.IsDefined(JsonIgnore))
{
return(false);
}
int serialization = 0;
if (attr.HasConstructorArguments && attr.ConstructorArguments[0].Type.FullName == "Newtonsoft.Json.MemberSerialization")
{
serialization = (int)attr.ConstructorArguments[0].Value;
}
else
{
foreach (var property in attr.Properties)
{
if (property.Name == "MemberSerialization")
{
serialization = (int)property.Value;
}
}
}
if (serialization == 0)
{ // OptOut
return((def is PropertyDef && ((PropertyDef)def).IsPublic()) ||
(def is FieldDef && ((FieldDef)def).IsPublic));
}
else if (serialization == 1) // OptIn
{
return(false);
}
else if (serialization == 2) // Fields
{
return(def is FieldDef);
}
else // Unknown
{
return(false);
}
}
/// <inheritdoc />
protected internal override void MarkMember(ISDnlibDef member, ConfuserContext context)
{
ModuleDef module = ((IMemberRef)member).Module;
var stack = context.Annotations.Get <ProtectionSettingsStack>(module, ModuleSettingsKey);
using (stack.Apply(member, Enumerable.Empty <ProtectionSettingsInfo>()))
return;
}
private void ParseParameters(ISDnlibDef def, ConfuserContext context, NameService service, ProtectionParameters parameters)
{
var mode = parameters.GetParameter <RenameMode?>(context, def, "mode", null);
if (mode != null)
{
service.SetRenameMode(def, mode.Value);
}
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
var a = (bool)OperandA.Evaluate(definition);
if (a)
{
return(true);
}
return((bool)OperandB.Evaluate(definition));
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
if (!(definition is IMemberDef) || ((IMemberDef)definition).DeclaringType == null)
{
return(false);
}
object fullName = Arguments[0].Evaluate(definition);
return(((IMemberDef)definition).DeclaringType.FullName == fullName.ToString());
}
/// <inheritdoc />
public ConfuserComponent GetHelperParent(ISDnlibDef def)
{
ConfuserComponent parent;
if (!helperParents.TryGetValue(def, out parent))
{
return(null);
}
return(parent);
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
TypeDef type = definition as TypeDef;
if (type == null && definition is IMemberDef)
{
type = ((IMemberDef)definition).DeclaringType;
}
if (type == null)
{
return(false);
}
string typeRegex = Arguments[0].Evaluate(definition).ToString();
var typeType = new StringBuilder();
if (type.IsEnum)
{
typeType.Append("enum ");
}
if (type.IsInterface)
{
typeType.Append("interface ");
}
if (type.IsValueType)
{
typeType.Append("valuetype ");
}
if (type.IsDelegate())
{
typeType.Append("delegate ");
}
if (type.IsAbstract)
{
typeType.Append("abstract ");
}
if (type.IsNested)
{
typeType.Append("nested ");
}
if (type.IsSerializable)
{
typeType.Append("serializable ");
}
return(Regex.IsMatch(typeType.ToString(), typeRegex));
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
if (!(definition is IOwnerModule) && !(definition is IModule))
{
return(false);
}
object name = Arguments[0].Evaluate(definition);
if (definition is IModule)
{
return(((IModule)definition).Name == name.ToString());
}
return(((IOwnerModule)definition).Module.Name == name.ToString());
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
if (definition is TypeDef)
{
string regex = Arguments[0].Evaluate(definition).ToString();
return(Regex.IsMatch(definition.Name, regex));
}
if (definition is IMemberDef && ((IMemberDef)definition).DeclaringType != null)
{
string regex = Arguments[0].Evaluate(definition).ToString();
return(Regex.IsMatch(((IMemberDef)definition).DeclaringType.Name, regex));
}
return(false);
}
public void Analyze(ISDnlibDef def)
{
if (analyze == null)
{
analyze = context.Pipeline.FindPhase <AnalyzePhase>();
}
SetOriginalName(def, def.Name);
if (def is TypeDef)
{
GetVTables().GetVTable((TypeDef)def);
SetOriginalNamespace(def, ((TypeDef)def).Namespace);
}
analyze.Analyze(this, context, ProtectionParameters.Empty, def, true);
}
private TypeDef GetAttributeType(ISDnlibDef attr)
{
ITypeDefOrRef retType = null;
if (attr is PropertyDef)
{
retType = ((PropertyDef)attr).PropertySig.RetType.ToBasicTypeDefOrRef();
}
else if (attr is EventDef)
{
retType = ((EventDef)attr).EventType;
}
return((retType == null) ? null : retType.ResolveTypeDefThrow());
throw new UnreachableException();
}
public void SetParam(ISDnlibDef def, string name, string value)
{
var param = ProtectionParameters.GetParameters(context, def);
if (param == null)
{
ProtectionParameters.SetParameters(context, def, param = new ProtectionSettings());
}
Dictionary <string, string> nameParam;
if (!param.TryGetValue(analyze.Parent, out nameParam))
{
param[analyze.Parent] = nameParam = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
}
nameParam[name] = value;
}
public string GetParam(ISDnlibDef def, string name)
{
var param = ProtectionParameters.GetParameters(context, def);
if (param == null)
{
return(null);
}
Dictionary <string, string> nameParam;
if (!param.TryGetValue(analyze.Parent, out nameParam))
{
return(null);
}
return(nameParam.GetValueOrDefault(name));
}
public IDisposable Apply(ISDnlibDef target, IEnumerable <ProtectionSettingsInfo> infos)
{
ProtectionSettings settings;
if (this.settings == null)
{
settings = new ProtectionSettings();
}
else
{
settings = new ProtectionSettings(this.settings);
}
var infoArray = infos.ToArray();
if (stack.Count > 0)
{
foreach (var i in stack.Reverse())
{
ApplyInfo(target, settings, i.Item2, ApplyInfoType.ParentInfo);
}
}
IDisposable result;
if (infoArray.Length != 0)
{
var originalSettings = this.settings;
// the settings that would apply to members
ApplyInfo(target, settings, infoArray, ApplyInfoType.CurrentInfoInherits);
this.settings = new ProtectionSettings(settings);
// the settings that would apply to itself
ApplyInfo(target, settings, infoArray, ApplyInfoType.CurrentInfoOnly);
stack.Push(Tuple.Create(originalSettings, infoArray));
result = new PopHolder(this);
}
else
{
result = null;
}
ProtectionParameters.SetParameters(context, target, settings);
return(result);
}
/// <summary>
/// Obtains the value of a parameter of the specified target.
/// </summary>
/// <typeparam name="T">The type of the parameter value.</typeparam>
/// <param name="context">The working context.</param>
/// <param name="target">The protection target.</param>
/// <param name="name">The name of the parameter.</param>
/// <param name="defValue">Default value if the parameter does not exist.</param>
/// <returns>The value of the parameter.</returns>
public T GetParameter <T>(ConfuserContext context, ISDnlibDef target, string name, T defValue = default(T))
{
Dictionary <string, string> parameters;
if (comp == null)
{
return(defValue);
}
if (comp is Packer && target == null)
{
// Packer parameters are stored in modules
target = context.Modules[0];
}
var objParams = context.Annotations.Get <ProtectionSettings>(target, ParametersKey);
if (objParams == null)
{
return(defValue);
}
if (!objParams.TryGetValue(comp, out parameters))
{
return(defValue);
}
string ret;
if (parameters.TryGetValue(name, out ret))
{
Type paramType = typeof(T);
Type nullable = Nullable.GetUnderlyingType(paramType);
if (nullable != null)
{
paramType = nullable;
}
if (paramType.IsEnum)
{
return((T)Enum.Parse(paramType, ret, true));
}
return((T)Convert.ChangeType(ret, paramType));
}
return(defValue);
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
var member = definition as IMemberDef;
if (member == null)
{
return(false);
}
var declType = ((IMemberDef)definition).DeclaringType;
while (declType != null)
{
if (!declType.IsPublic)
{
return(false);
}
declType = declType.DeclaringType;
}
if (member is MethodDef)
{
return(((MethodDef)member).IsPublic);
}
if (member is FieldDef)
{
return(((FieldDef)member).IsPublic);
}
if (member is PropertyDef)
{
return(((PropertyDef)member).IsPublic());
}
if (member is EventDef)
{
return(((EventDef)member).IsPublic());
}
if (member is TypeDef)
{
return(((TypeDef)member).IsPublic || ((TypeDef)member).IsNestedPublic);
}
throw new NotSupportedException();
}
/// <inheritdoc />
public void Mark(ISDnlibDef member, ConfuserComponent parentComp)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
if (member is ModuleDef)
{
throw new ArgumentException("New ModuleDef cannot be marked.");
}
if (IsMarked(member)) // avoid double marking
{
return;
}
marker.MarkMember(member, context);
if (parentComp != null)
{
helperParents[member] = parentComp;
}
}
private Tuple <ISDnlibDef, AttributeInfoRecord, TypeDef> AnalyzeAttributeReference(TypeDef declType, AttributeInfoRecord rec)
{
ISDnlibDef retDef = null;
ITypeDefOrRef retType = null;
while (declType != null)
{
PropertyDef property = declType.FindProperty(rec.Name);
if (property != null)
{
retDef = property;
retType = property.PropertySig.RetType.ToBasicTypeDefOrRef();
if (context.Modules.Contains((ModuleDefMD)declType.Module))
{
service.AddReference(property, new BAMLAttributeReference(property, rec));
}
break;
}
EventDef evt = declType.FindEvent(rec.Name);
if (evt != null)
{
retDef = evt;
retType = evt.EventType;
if (context.Modules.Contains((ModuleDefMD)declType.Module))
{
service.AddReference(evt, new BAMLAttributeReference(evt, rec));
}
break;
}
if (declType.BaseType == null)
{
break;
}
declType = declType.BaseType.ResolveTypeDefThrow();
}
return(Tuple.Create(retDef, rec, retType == null ? null : retType.ResolveTypeDefThrow()));
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
string name = Arguments[0].Evaluate(definition).ToString();
var type = definition as TypeDef;
if (type == null && definition is IMemberDef)
{
type = ((IMemberDef)definition).DeclaringType;
}
if (type == null)
{
return(false);
}
if (type.InheritsFrom(name) || type.Implements(name))
{
return(true);
}
return(false);
}
public void MarkHelper(ISDnlibDef def, IMarkerService marker, ConfuserComponent parentComp)
{
if (marker.IsMarked(def))
{
return;
}
if (def is MethodDef)
{
var method = (MethodDef)def;
method.Access = MethodAttributes.Assembly;
if (!method.IsSpecialName && !method.IsRuntimeSpecialName && !method.DeclaringType.IsDelegate())
{
method.Name = RandomName();
}
}
else if (def is FieldDef)
{
var field = (FieldDef)def;
field.Access = FieldAttributes.Assembly;
if (!field.IsSpecialName && !field.IsRuntimeSpecialName)
{
field.Name = RandomName();
}
}
else if (def is TypeDef)
{
var type = (TypeDef)def;
type.Visibility = type.DeclaringType == null ? TypeAttributes.NotPublic : TypeAttributes.NestedAssembly;
type.Namespace = "";
if (!type.IsSpecialName && !type.IsRuntimeSpecialName)
{
type.Name = RandomName();
}
}
SetCanRename(def, false);
Analyze(def);
marker.Mark(def, parentComp);
}
private void ProcessMember(ISDnlibDef member, ProtectionSettingsStack stack)
{
using (stack.Apply(member, ReadInfos(member)))
ProcessBody(member as MethodDef, stack);
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, ISDnlibDef def)
{
if (def is TypeDef)
{
Analyze(context, service, (TypeDef)def, parameters);
}
else if (def is MethodDef)
{
Analyze(context, service, (MethodDef)def, parameters);
}
else if (def is PropertyDef)
{
Analyze(context, service, (PropertyDef)def, parameters);
}
else if (def is FieldDef)
{
Analyze(context, service, (FieldDef)def, parameters);
}
}
public void PostRename(ConfuserContext context, INameService service, ProtectionParameters parameters, ISDnlibDef def)
{
//
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
return(!(bool)OperandA.Evaluate(definition));
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
return(Literal);
}
/// <inheritdoc />
public override object Evaluate(ISDnlibDef definition)
{
string attrName = Arguments[0].Evaluate(definition).ToString();
return(definition.CustomAttributes.IsDefined(attrName));
}
