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