public static bool CanObfuscateMembers(dynamic obj) { CustomAttribute obfuscationAttribute = GetObfuscationAttribute(obj); if (obfuscationAttribute == null) { return(true); } CANamedArgument exclude = obfuscationAttribute.GetProperty("Exclude"); CANamedArgument includeMembers = obfuscationAttribute.GetProperty("ApplyToMembers"); if (exclude == null || includeMembers == null) { return(true); } if ((bool)exclude.Value == true && (bool)includeMembers.Value == true) { return(false); } return(true); }
void Add(CANamedArgument arg) { if (arg is null) { return; } Add(arg.Type); Add(arg.Argument); }
void add(CANamedArgument arg) { if (arg == null) { return; } add(arg.Type); add(arg.Argument); }
void Load(CANamedArgument obj) { if (obj == null) { return; } Add(obj.Type); Add(obj.Name); Load(obj.Argument); }
void Write(IList <CANamedArgument> namedArgs) { if (namedArgs == null || namedArgs.Count > 0x1FFFFFFF) { helper.Error("Too many custom attribute named arguments"); namedArgs = new CANamedArgument[0]; } writer.WriteCompressedUInt32((uint)namedArgs.Count); for (int i = 0; i < namedArgs.Count; i++) { Write(namedArgs[i]); } }
private static IMemberDef FindArgumentMemberDef(CANamedArgument arg, TypeDef attrType) { if (arg.IsField) { return(FindArgumentMemberDef(arg.Name, new FieldSig(arg.Type), attrType)); } if (arg.IsProperty) { return(FindArgumentMemberDef(arg.Name, new PropertySig(true, arg.Type), attrType)); } throw new UnreachableException(); }
CANamedArgument Clone(ITypeDefOrRef sourceType, CANamedArgument source) { var name = source.Name; var st = sourceType.ResolveTypeDefThrow(); var member = source.IsField ? (IMemberDef)st.FindFieldCheckBaseType(name) : st.FindPropertyCheckBaseType(name); if (Context.Plugin <INaming>().FindNewName(member, out _, out var newName)) { name = newName; } return(new CANamedArgument(source.IsField, Importer.Import(source.Type), name, Clone(source.Argument))); }
void InitializeFrom(CANamedArgument namedArg, TypeSigCreatorOptions options) { if (CAArgumentVM != null) { CAArgumentVM.PropertyChanged -= caArgumentVM_PropertyChanged; } CAArgumentVM = new CAArgumentVM(ownerModule, namedArg.Argument, options, null); OnPropertyChanged(nameof(CAArgumentVM)); CAArgumentVM.PropertyChanged += caArgumentVM_PropertyChanged; Name = namedArg.Name; IsField = namedArg.IsField; ConstantTypeEnumList.SelectedItem = GetConstantType(namedArg.Type, out var newEnumType); EnumType = newEnumType; CAArgumentVM.StorageType = GetType((ConstantType)ConstantTypeEnumList.SelectedItem); }
public static bool CanObfuscate(dynamic obj) { CustomAttribute obfuscationAttribute = GetObfuscationAttribute(obj); if (obfuscationAttribute == null) { return(true); } CANamedArgument exclude = obfuscationAttribute.GetProperty("Exclude"); if (exclude == null) { return(false); } if ((bool)exclude.Value == true) { return(false); } return(true); }
/// <summary> /// Creates a custom ObfuscationAttribute that can be added to a method. /// </summary> /// <param name="module">Module</param> /// <param name="feature">Obfuscation feature name</param> /// <param name="exclude">true if exclude, false if include</param> /// <returns>CustomAttribute</returns> CustomAttribute CreateAttribute(ModuleDef module, String feature, Boolean exclude) { TypeSig stringSig = module.CorLibTypes.String; TypeSig booleanSig = module.CorLibTypes.Boolean; CANamedArgument[] args = new CANamedArgument[] { // Feature new CANamedArgument( false, stringSig, "Feature", new CAArgument(stringSig, feature)), // Exclude new CANamedArgument( false, booleanSig, "Exclude", new CAArgument(booleanSig, exclude)) }; TypeRef obfuscationRef = new TypeRefUser( module, "System.Reflection", "ObfuscationAttribute", module.CorLibTypes.AssemblyRef); MemberRef obfuscationCtor = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), obfuscationRef); CustomAttribute attr = new CustomAttribute( obfuscationCtor, new CAArgument[0], args ); return(attr); }
void Write(CANamedArgument namedArg) { if (namedArg == null) { helper.Error("Custom attribute named arg is null"); return; } if (!recursionCounter.Increment()) { helper.Error("Infinite recursion"); return; } if (namedArg.IsProperty) writer.Write((byte)SerializationType.Property); else writer.Write((byte)SerializationType.Field); WriteFieldOrPropType(namedArg.Type); WriteUTF8String(namedArg.Name); WriteValue(namedArg.Type, namedArg.Argument); recursionCounter.Decrement(); }
void Write(IList<CANamedArgument> namedArgs) { if (namedArgs == null || namedArgs.Count > 0x1FFFFFFF) { helper.Error("Too many custom attribute named arguments"); namedArgs = new CANamedArgument[0]; } writer.WriteCompressedUInt32((uint)namedArgs.Count); for (int i = 0; i < namedArgs.Count; i++) Write(namedArgs[i]); }
void Add(CANamedArgument obj) => AddToStack(obj);