/// <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)); }