¿Cómo puedo evitar que un código no autorizado acceda a mi ensamblaje en .NET 2.0?

Question

En .NET 1.x, puede usar StrongNameIdentityPermissionAttribute en su ensamblaje para garantizar que solo el código firmado por usted pueda acceder a su ensamblaje. Según la documentación de MSDN,

  

En .NET Framework versión 2.0 y posteriores, las demandas de identidad   los permisos no son efectivos si el ensamblado que llama tiene plena confianza.

Esto significa que cualquier aplicación con plena confianza puede pasar por alto mis demandas de seguridad.

¿Cómo puedo evitar que un código no autorizado acceda a mi ensamblaje en .NET 2.0?

Answer 1

Según la sugerencia de Eric, lo resolví comprobando la clave yo mismo. En el código que quiero proteger, agrego la siguiente llamada,

EnsureAssemblyIsSignedByMyCompany( Assembly.GetCallingAssembly() );

Entonces la implementación de ese método es

  /// <summary>
  /// Ensures that the given assembly is signed by My Company or Microsoft.
  /// </summary>
  /// <param name="assembly"></param>
  private static void EnsureAssemblyIsSignedByMyCompany( Assembly assembly )
  {
     if ( assembly == null )
        throw new ArgumentNullException( "assembly" );

     byte[] pubkey = assembly.GetName().GetPublicKeyToken();
     if ( pubkey.Length == 0 )
        throw new ArgumentException( "No public key token in assembly." );

     StringBuilder builder = new StringBuilder();
     foreach ( byte b in pubkey )
     {
        builder.AppendFormat( "{0:x2}", b );
     }
     string pkString = builder.ToString();
     if ( pkString != "b77a5c561934e089" /* Microsoft */ &&
          pkString != "abababababababab" /* Ivara */ )
     {
        throw new ArgumentException( "Assembly is not signed by My Company or Microsoft. You do not have permission to call this code." );
     }
  }

** Se han cambiado los nombres y las claves para proteger a los inocentes. Cualquier parecido con nombres reales o compañías es simplemente una coincidencia. *

Answer 2

Ver este artículo:
http: // blogs.msdn.com/ericlippert/archive/2008/10/06/preventing-third-party-derivation-part-two.aspx

Particularmente esta parte:

  

En las versiones recientes de .NET, " confianza total significa confianza completa " ;. Es decir, el código en el que se confía plenamente satisface todas las demandas, incluidas las demandas de elementos como "se firmó con esta clave", independientemente de si se firmó o no.

     

¿No es esa una falla mortal en el sistema de seguridad? No. El código totalmente confiable siempre tuvo la capacidad de hacerlo, porque el código totalmente confiable tiene la capacidad de controlar la evidencia asociada con un ensamblaje determinado. Si puede controlar la evidencia, entonces puede forjar un conjunto que parece provenir de Microsoft, no hay problema. (Y si ya tiene un código malintencionado de plena confianza en su proceso, entonces ya lo ha perdido, no es necesario suplantar los ensamblados firmados por Microsoft; ya tiene el poder de hacer lo que sea que el usuario pueda hacer).

Al parecer, los diseñadores de .Net consideraron que este atributo tampoco era muy efectivo para el código de plena confianza en .Net 1.x.

Answer 3

Como Joel indicó, no tienes suerte con respecto a CAS. Sin embargo, puede realizar la comprobación usted mismo en cualquier método que necesite proteger mediante el uso de Assembly.GetCallingAssembly () para obtener una referencia al ensamblaje que contiene el código de llamada, luego verifique el nombre seguro en ese ensamblaje manualmente.