private void MarkType(TypeDefinition type, Marking mark, List <MemberSetting> settings) { bool exclude; MemberSetting ret = MarkType(type, mark, out exclude); ret.Parameters = mark.CurrentConfusions; if (!exclude) { List <MemberSetting> memSettings = new List <MemberSetting>(); foreach (TypeDefinition nType in type.NestedTypes) { mark.StartLevel(); MarkType(nType, mark, memSettings); mark.LeaveLevel(); } foreach (MethodDefinition mtd in type.Methods) { mark.StartLevel(); MarkMember(mtd, mark, Target.Methods, memSettings); mark.LeaveLevel(); } foreach (FieldDefinition fld in type.Fields) { mark.StartLevel(); MarkMember(fld, mark, Target.Fields, memSettings); mark.LeaveLevel(); } foreach (PropertyDefinition prop in type.Properties) { mark.StartLevel(); MarkMember(prop, mark, Target.Properties, memSettings); mark.LeaveLevel(); } foreach (EventDefinition evt in type.Events) { mark.StartLevel(); MarkMember(evt, mark, Target.Events, memSettings); mark.LeaveLevel(); } ret.Members = memSettings.ToArray(); } if (!ret.Parameters.IsEmpty() || ret.Members.Length != 0) { settings.Add(ret); } mark.LeaveLevel(); }
private void MarkModule(ModuleDefinition mod, Marking mark, List <ModuleSetting> settings) { bool exclude; ModuleSetting ret = MarkModule(mod, mark, out exclude); ret.Parameters = mark.CurrentConfusions; if (!exclude) { List <MemberSetting> typeSettings = new List <MemberSetting>(); foreach (TypeDefinition type in mod.Types) { mark.StartLevel(); MarkType(type, mark, typeSettings); mark.LeaveLevel(); } ret.Members = typeSettings.ToArray(); } settings.Add(ret); mark.LeaveLevel(); }
private void MarkMember(IMemberDefinition mem, Marking mark, Target target, List <MemberSetting> settings) { if (target == Target.Methods && (mem as MethodDefinition).SemanticsAttributes != MethodSemanticsAttributes.None) { return; } bool exclude; MemberSetting ret = MarkMember(mem, mark, out exclude); ret.Parameters = mark.CurrentConfusions; if (!exclude) { List <MemberSetting> semSettings = new List <MemberSetting>(); if (target == Target.Properties) { PropertyDefinition prop = mem as PropertyDefinition; List <MethodDefinition> sems = new List <MethodDefinition>(); if (prop.GetMethod != null) { sems.Add(prop.GetMethod); } if (prop.SetMethod != null) { sems.Add(prop.SetMethod); } if (prop.HasOtherMethods) { sems.AddRange(prop.OtherMethods); } foreach (MethodDefinition mtd in sems) { mark.StartLevel(); ProcessAttribute(mtd, mark); semSettings.Add(new MemberSetting(mtd) { Parameters = mark.CurrentConfusions, Members = new MemberSetting[0] }); mark.LeaveLevel(); mark.LeaveLevel(); } } else if (target == Target.Events) { EventDefinition evt = mem as EventDefinition; List <MethodDefinition> sems = new List <MethodDefinition>(); if (evt.AddMethod != null) { sems.Add(evt.AddMethod); } if (evt.RemoveMethod != null) { sems.Add(evt.RemoveMethod); } if (evt.InvokeMethod != null) { sems.Add(evt.InvokeMethod); } if (evt.HasOtherMethods) { sems.AddRange(evt.OtherMethods); } foreach (MethodDefinition mtd in sems) { mark.StartLevel(); ProcessAttribute(mtd, mark); semSettings.Add(new MemberSetting(mtd) { Parameters = mark.CurrentConfusions, Members = new MemberSetting[0] }); mark.LeaveLevel(); mark.LeaveLevel(); } } ret.Members = semSettings.ToArray(); } if (!ret.Parameters.IsEmpty() || ret.Members.Length != 0) { settings.Add(ret); } mark.LeaveLevel(); }
private bool ProcessAttribute(ICustomAttributeProvider provider, Marking setting) { CustomAttribute att = GetAttribute(provider.CustomAttributes, "ConfusingAttribute"); if (att == null) { setting.StartLevel(); return(false); } CustomAttributeNamedArgument stripArg = att.Properties.FirstOrDefault(arg => arg.Name == "StripAfterObfuscation"); bool strip = true; if (!stripArg.Equals(default(CustomAttributeNamedArgument))) { strip = (bool)stripArg.Argument.Value; } if (strip) { provider.CustomAttributes.Remove(att); } CustomAttributeNamedArgument excludeArg = att.Properties.FirstOrDefault(arg => arg.Name == "Exclude"); bool exclude = false; if (!excludeArg.Equals(default(CustomAttributeNamedArgument))) { exclude = (bool)excludeArg.Argument.Value; } if (exclude) { setting.CurrentConfusions.Clear(); } CustomAttributeNamedArgument applyToMembersArg = att.Properties.FirstOrDefault(arg => arg.Name == "ApplyToMembers"); bool applyToMembers = true; if (!applyToMembersArg.Equals(default(CustomAttributeNamedArgument))) { applyToMembers = (bool)applyToMembersArg.Argument.Value; } if (applyToMembers) { setting.StartLevel(); } else { setting.SkipLevel(); } try { if (!exclude) { CustomAttributeNamedArgument featureArg = att.Properties.FirstOrDefault(arg => arg.Name == "Config"); string feature = "all"; if (!featureArg.Equals(default(CustomAttributeNamedArgument))) { feature = (string)featureArg.Argument.Value; } if (string.Equals(feature, "all", StringComparison.OrdinalIgnoreCase)) { FillPreset(Preset.Maximum, setting.CurrentConfusions); } else if (string.Equals(feature, "default", StringComparison.OrdinalIgnoreCase)) { FillPreset(Preset.Normal, setting.CurrentConfusions); } else { ProcessConfig(feature, setting.CurrentConfusions); } } return(exclude && applyToMembers); } catch { cr.Log("Warning: Cannot process ConfusingAttribute at '" + provider.ToString() + "'. ConfusingAttribute ignored."); return(false); } }