Why is .Net best practice to design custom attributes as sealed?

Question

I'm reading Pro C# 2010 and the .Net 4 Platform by Andrew Troelsen.

In Chapter 15 about Attributes exists a note:

Note: For security reasons, it is considered a .Net best practice to design all custom attributes as sealed.

The author doesn't explain why, can someone explain why?

Answer 1

CA1813: Avoid unsealed attributes: The .NET Framework class library provides methods for retrieving custom attributes. By default, these methods search the attribute inheritance hierarchy; for example Attribute.GetCustomAttribute searches for the specified attribute type, or any attribute type that extends the specified attribute type. Sealing the attribute eliminates the search through the inheritance hierarchy, and can improve performance.

Ref: https://docs.microsoft.com/visualstudio/code-quality/ca1813-avoid-unsealed-attributes

Attributes are simply metadata discovered at runtime. As it is quoted, if someone else derives from your custom attribute class, by default .NET will find them too, which may imply a security risk if the derived attribute class is modifying the behavior of your original attribute in a way to you never intended to.

Even though performance is the prime reason to seal attribute classes, here is a formidable article dealing with its security side.

Answer 2

There is one more reason to seal attributes.

Consider the following attribute:

[AttributeUsageAttribute(AttributeTargets.Class, AllowMultiple = false)] public class Attr1 : Attribute { } 

Here you allow only single attribute decoration: AllowMultiple = false

Compiler won't allow this:

[Attr1] [Attr1] public class Foo { } 

Later in your code you can safely call memberInfo.GetCustomAttribute() which will throw AmbiguousMatchException if more then one attribute of the given type was found.

Let's now inherit:

public class Attr2 : Attr1 { } 

Now compiler is silent.

[Attr1] [Attr2] public class Foo { } 

So if later somebody inherits from your attribute and passes back to your code some entity marked with both attributes unexpected exception will be thrown.

Full example:

class Program {     static void Main(params string[] args)     {         typeof(Foo).GetCustomAttribute<Attr1>();     }      [AttributeUsageAttribute(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]     public class Attr1 : Attribute     {     }      public class Attr2 : Attr1     {     }      [Attr1]     [Attr2]     public class Foo     {     }      [Attr1]     public class Bar : Foo     {     } }