Utilizzo del metodo AssertUsing the Assert Method

Attenzione

Sicurezza dall'accesso di codice e codice parzialmente attendibileCode Access Security and Partially Trusted Code

.NET Framework fornisce un meccanismo denominato sicurezza dall'accesso di codice, che consente di applicare vari livelli di attendibilità a codice diverso in esecuzione nella stessa applicazione.The .NET Framework provides a mechanism for the enforcement of varying levels of trust on different code running in the same application called Code Access Security (CAS). La sicurezza per l'accesso di codice in .NET Framework non deve essere usata come meccanismo per l'applicazione dei limiti di sicurezza in base alla creazione di codice o altri aspetti di identità.Code Access Security in .NET Framework should not be used as a mechanism for enforcing security boundaries based on code origination or other identity aspects. Le linee guida sono state modificate per specificare che la sicurezza per l'accesso di codice e il codice SecurityTransparent non saranno supportati come limiti di sicurezza con codice parzialmente attendibile, soprattutto nel caso di codice di origine sconosciuta.We are updating our guidance to reflect that Code Access Security and Security-Transparent Code will not be supported as a security boundary with partially trusted code, especially code of unknown origin. Non è consigliabile caricare ed eseguire codice di origine sconosciuta in assenza di misure di sicurezza alternative.We advise against loading and executing code of unknown origins without putting alternative security measures in place.

Questi criteri si applicano a tutte le versioni di .NET Framework, ma non alla versione di .NET Framework inclusa in Silverlight.This policy applies to all versions of .NET Framework, but does not apply to the .NET Framework included in Silverlight.

Assert è un metodo che può essere chiamato nelle classi di autorizzazione di accesso al codice e nella classe PermissionSet.Assert is a method that can be called on code access permission classes and on the PermissionSet class. È possibile utilizzare Assert per abilitare il codice (e i chiamanti downstream) per eseguire azioni che il codice è autorizzato a eseguire, ma i chiamanti potrebbero non disporre delle autorizzazioni necessarie.You can use Assert to enable your code (and downstream callers) to perform actions that your code has permission to do but its callers might not have permission to do. Un'asserzione di sicurezza modifica il normale processo eseguito dal runtime durante un controllo di sicurezza.A security assertion changes the normal process that the runtime performs during a security check. Mediante l'asserzione di un'autorizzazione si impone al sistema di sicurezza di non eseguire il controllo dei chiamanti del codice relativamente all'autorizzazione oggetto dell'asserzione.When you assert a permission, it tells the security system not to check the callers of your code for the asserted permission.

Attenzione

Usare con cautela le asserzioni, in quanto possono introdurre vulnerabilità nella sicurezza e compromettere il meccanismo runtime per l'applicazione delle restrizioni di sicurezza.Use assertions carefully because they can open security holes and undermine the runtime's mechanism for enforcing security restrictions.

Le asserzioni risultano utili nelle situazioni in cui una libreria chiama codice non gestito o effettua una chiamata che richiede un'autorizzazione non direttamente correlata all'uso previsto della libreria.Assertions are useful in situations in which a library calls into unmanaged code or makes a call that requires a permission that is not obviously related to the library's intended use. Ad esempio, tutto il codice gestito che chiama il codice non gestito deve avere SecurityPermission con il flag UnmanagedCode specificato.For example, all managed code that calls into unmanaged code must have SecurityPermission with the UnmanagedCode flag specified. Per impostazione predefinita, al codice che non ha origine nel computer locale, ad esempio quello scaricato dalla rete Intranet locale, non viene concessa questa autorizzazione.Code that does not originate from the local computer, such as code that is downloaded from the local intranet, will not be granted this permission by default. Pertanto, affinché il codice scaricato dalla rete Intranet locale possa chiamare una libreria che usa codice non gestito, è necessaria un'asserzione dell'autorizzazione da parte della libreria.Therefore, in order for code that is downloaded from the local intranet to be able to call a library that uses unmanaged code, it must have the permission asserted by the library. Alcune librerie possono inoltre effettuare chiamate invisibili ai chiamanti e che richiedono autorizzazioni speciali.Additionally, some libraries might make calls that are unseen to callers and require special permissions.

Le asserzioni possono anche essere usate nelle situazioni in cui il codice accede a una risorsa in modo completamente invisibile ai chiamanti.You can also use assertions in situations in which your code accesses a resource in a way that is completely hidden from callers. Si supponga, ad esempio, che la libreria acquisisca informazioni da un database, ma durante il processa legga anche informazioni dal Registro di sistema del computer.For example, suppose your library acquires information from a database, but in the process also reads information from the computer registry. Poiché gli sviluppatori che usano la libreria non hanno accesso all'origine, non hanno modo di sapere che il codice richiede RegistryPermission per poter usare il codice.Because developers using your library do not have access to your source, they have no way of knowing that their code requires RegistryPermission in order to use your code. In questo caso, se si stabilisce che non è ragionevole o necessario richiedere che i chiamanti del codice dispongano di un'autorizzazione per accedere al Registro di sistema, è possibile effettuare un'asserzione dell'autorizzazione di lettura del Registro di sistema.In this case, if you decide that it is not reasonable or necessary to require that callers of your code have permission to access the registry, you can assert permission for reading the registry. In questa situazione è opportuno che la libreria affermi l'autorizzazione in modo che i chiamanti senza RegistryPermission possano usare la libreria.In this situation, it is appropriate for the library to assert the permission so that callers without RegistryPermission can use the library.

L'asserzione influisce sul percorso stack solo se l'autorizzazione che ne è oggetto e l'autorizzazione richiesta da un chiamante downstream sono dello stesso tipo e se l'autorizzazione richiesta è un subset dell'autorizzazione oggetto dell'asserzione.The assertion affects the stack walk only if the asserted permission and a permission demanded by a downstream caller are of the same type and if the demanded permission is a subset of the asserted permission. Se, ad esempio, si dichiara FileIOPermission per leggere tutti i file nell'unità C e viene eseguita una richiesta downstream per la lettura dei file in C:\Temp da parte di FileIOPermission , l'asserzione potrebbe influire sul percorso stack. Tuttavia, se la richiesta era relativa a FileIOPermission per la scrittura nell'unità C, l'asserzione non avrebbe alcun effetto.For example, if you assert FileIOPermission to read all files on the C drive, and a downstream demand is made for FileIOPermission to read files in C:\Temp, the assertion could affect the stack walk; however, if the demand was for FileIOPermission to write to the C drive, the assertion would have no effect.

Perché sia possibile effettuare asserzioni, è necessario concedere al codice sia l'autorizzazione oggetto dell'asserzione sia SecurityPermission, che rappresenta il diritto di effettuare asserzioni.To perform assertions, your code must be granted both the permission you are asserting and the SecurityPermission that represents the right to make assertions. Benché sia possibile effettuare l'asserzione di un'autorizzazione non concessa al codice, tale operazione non avrebbe alcun significato, poiché il controllo di sicurezza avrebbe esito negativo ancor prima che l'asserzione possa garantirne la riuscita.Although you could assert a permission that your code has not been granted, the assertion would be pointless because the security check would fail before the assertion could cause it to succeed.

Nella figura seguente viene illustrato cosa accade quando si utilizza Assert.The following illustration shows what happens when you use Assert. Si supponga che le affermazioni seguenti siano valide per gli assembly A, B, C, E e F e le due autorizzazioni P1 e P1A:Assume that the following statements are true about assemblies A, B, C, E, and F, and two permissions, P1 and P1A:

  • P1A rappresenta il diritto di leggere i file TXT presenti nell'unità C.P1A represents the right to read .txt files on the C drive.

  • P1 rappresenta il diritto di leggere tutti i file presenti nell'unità C.P1 represents the right to read all files on the C drive.

  • P1A e P1 sono entrambi tipi FileIOPermission e P1A è un subset di P1.P1A and P1 are both FileIOPermission types, and P1A is a subset of P1.

  • Agli assembly E ed F è stata concessa l'autorizzazione P1A.Assemblies E and F have been granted P1A permission.

  • All'assembly C è stata concessa l'autorizzazione P1.Assembly C has been granted P1 permission.

  • Agli assembly A e B non è stata concessa né l'autorizzazione P1 né l'autorizzazione P1A.Assemblies A and B have been granted neither P1 nor P1A permissions.

  • Il metodo A è incluso nell'assembly A, il metodo B nell'assembly B e così via.Method A is contained in assembly A, method B is contained in assembly B, and so on.

Diagramma che Mostra gli assembly del metodo Assert.

In questo scenario, il metodo A chiama B, B chiama C, C chiama E e e chiama F. il metodo C asserisce l'autorizzazione per leggere i file nell'unità C (autorizzazione P1) e il metodo e richiede l'autorizzazione per leggere i file con estensione txt nell'unità C (autorizzazione P1A).In this scenario, method A calls B, B calls C, C calls E, and E calls F. Method C asserts permission to read files on the C drive (permission P1), and method E demands permission to read .txt files on the C drive (permission P1A). Quando viene rilevata la richiesta in F in fase di esecuzione, viene eseguito un percorso stack per verificare le autorizzazioni di tutti i chiamanti di F, a partire da E. a è stata concessa l'autorizzazione P1A, quindi il percorso stack procede per esaminare le autorizzazioni di C, dove viene individuata l'asserzione di C.When the demand in F is encountered at run time, a stack walk is performed to check the permissions of all callers of F, starting with E. E has been granted P1A permission, so the stack walk proceeds to examine the permissions of C, where C's assertion is discovered. Poiché l'autorizzazione richiesta (P1A) è un subset dell'autorizzazione oggetto dell'asserzione (P1), il percorso stack si interrompe e automaticamente il controllo di sicurezza ha esito positivo.Because the demanded permission (P1A) is a subset of the asserted permission (P1), the stack walk stops and the security check automatically succeeds. Non è importante che agli assembly A e B non sia stata concessa l'autorizzazione P1A.It does not matter that assemblies A and B have not been granted permission P1A. Con l'asserzione di P1, il metodo C garantisce che i chiamanti possano accedere alla risorsa protetta da P1, anche se non è stata loro concessa l'autorizzazione di accesso.By asserting P1, method C ensures that its callers can access the resource protected by P1, even if the callers have not been granted permission to access that resource.

Se si progetta una libreria di classi e una classe accede a una risorsa protetta, nella maggior parte dei casi è consigliabile effettuare una richiesta di sicurezza che imponga ai chiamanti della classe di disporre dell'autorizzazione appropriata.If you design a class library and a class accesses a protected resource, you should, in most cases, make a security demand requiring that the callers of the class have the appropriate permission. Se la classe esegue un'operazione per la quale si conosce la maggior parte dei chiamanti non avrà l'autorizzazione e se si è disposti ad assumere la responsabilità di consentire a questi chiamanti di chiamare il codice, è possibile dichiarare l'autorizzazione chiamando il metodo Assert su un oggetto autorizzazione che rappresenta l'operazione eseguita dal codice.If the class then performs an operation for which you know most of its callers will not have permission, and if you are willing to take the responsibility for letting these callers call your code, you can assert the permission by calling the Assert method on a permission object that represents the operation the code is performing. L'uso di Assert in questo modo consente ai chiamanti che in genere non possono eseguire chiamate al codice.Using Assert in this way lets callers that normally could not do so call your code. Quando si effettua quindi l'asserzione di un'autorizzazione, è necessario assicurarsi di avere precedentemente eseguito gli opportuni controlli di sicurezza per impedire l'uso improprio del componente.Therefore, if you assert a permission, you should be sure to perform appropriate security checks beforehand to prevent your component from being misused.

Si supponga, ad esempio, che una classe di libreria altamente attendibile disponga di un metodo per l'eliminazione di file.For example, suppose your highly trusted library class has a method that deletes files. L'accesso al file viene effettuato chiamando una funzione Win32 non gestita.It accesses the file by calling an unmanaged Win32 function. Un chiamante richiama il metodo Delete del codice, passando il nome del file da eliminare, C:\test.txt.A caller invokes your code's Delete method, passing in the name of the file to be deleted, C:\Test.txt. All'interno del metodo Delete , il codice crea FileIOPermission un oggetto che rappresenta l'accesso in scrittura a C:\test.txt.Within the Delete method, your code creates a FileIOPermission object representing write access to C:\Test.txt. L'accesso in scrittura è necessario per l'eliminazione di un file. Il codice richiama quindi un controllo di sicurezza imperativo chiamando il metodo Demand dell'oggetto FileIOPermission .(Write access is required to delete a file.) Your code then invokes an imperative security check by calling the FileIOPermission object's Demand method. Se uno dei chiamanti inclusi nello stack di chiamate non dispone di questa autorizzazione, viene generata un'eccezione SecurityException.If one of the callers in the call stack does not have this permission, a SecurityException is thrown. Se non viene generata alcuna eccezione, significa che tutti i chiamanti hanno il diritto di accedere a C:\Test.txt.If no exception is thrown, you know that all callers have the right to access C:\Test.txt. Poiché si ritiene che la maggior parte dei chiamanti non sarà autorizzato ad accedere al codice non gestito, il codice crea quindi un SecurityPermission oggetto che rappresenta il diritto di chiamare codice non gestito e chiama il metodo Assert dell'oggetto.Because you believe that most of your callers will not have permission to access unmanaged code, your code then creates a SecurityPermission object that represents the right to call unmanaged code and calls the object's Assert method. Infine, chiama la funzione Win32 non gestita per eliminare C:\Test.txt e restituisce il controllo al chiamante.Finally, it calls the unmanaged Win32 function to delete C:\Text.txt and returns control to the caller.

Attenzione

È necessario assicurarsi che il codice non usi asserzioni in situazioni in cui può essere usato da altro codice per accedere a una risorsa protetta dall'autorizzazione oggetto dell'asserzione.You must be sure that your code does not use assertions in situations where your code can be used by other code to access a resource that is protected by the permission you are asserting. Ad esempio, nel codice che scrive in un file il cui nome è specificato dal chiamante come parametro, non è necessario dichiarare l'oggetto FileIOPermission per la scrittura nei file perché il codice potrebbe essere utilizzato in modo improprio da terze parti.For example, in code that writes to a file whose name is specified by the caller as a parameter, you would not assert the FileIOPermission for writing to files because your code would be open to misuse by a third party.

Quando si usa la sintassi di sicurezza imperativa, la chiamata al metodo Assert su più autorizzazioni nello stesso metodo comporta la generazione di un'eccezione di sicurezza.When you use the imperative security syntax, calling the Assert method on multiple permissions in the same method causes a security exception to be thrown. È invece consigliabile creare un oggetto PermissionSet , passargli le singole autorizzazioni da richiamare, quindi chiamare il metodo Assert sull'oggetto PermissionSet .Instead, you should create a PermissionSet object, pass it the individual permissions you want to invoke, and then call the Assert method on the PermissionSet object. È possibile chiamare il metodo Assert più di una volta quando si usa la sintassi di sicurezza dichiarativa.You can call the Assert method more than once when you use the declarative security syntax.

Nell'esempio seguente viene illustrata la sintassi dichiarativa per l'override dei controlli di sicurezza tramite il metodo Assert .The following example shows declarative syntax for overriding security checks using the Assert method. Si noti che la sintassi FileIOPermissionAttribute accetta due valori: SecurityAction un'enumerazione e il percorso del file o della directory a cui deve essere concessa l'autorizzazione.Notice that the FileIOPermissionAttribute syntax takes two values: a SecurityAction enumeration and the location of the file or directory to which permission is to be granted. La chiamata a Assert causa la riuscita della richiesta C:\Log.txt di accesso a, anche se non viene verificata l'autorizzazione di accesso al file da parte dei chiamanti.The call to Assert causes demands for access to C:\Log.txt to succeed, even though callers are not checked for permission to access the file.

Option Explicit  
Option Strict  
  
Imports System  
Imports System.IO  
Imports System.Security.Permissions  
  
Namespace LogUtil  
   Public Class Log  
      Public Sub New()  
  
      End Sub  
  
     <FileIOPermission(SecurityAction.Assert, All := "C:\Log.txt")> Public Sub   
      MakeLog()  
         Dim TextStream As New StreamWriter("C:\Log.txt")  
         TextStream.WriteLine("This  Log was created on {0}", DateTime.Now) '  
         TextStream.Close()  
      End Sub  
   End Class  
End Namespace  
namespace LogUtil  
{  
   using System;  
   using System.IO;  
   using System.Security.Permissions;  
  
   public class Log  
   {  
      public Log()  
      {      
      }     
      [FileIOPermission(SecurityAction.Assert, All = @"C:\Log.txt")]  
      public void MakeLog()  
      {     
         StreamWriter TextStream = new StreamWriter(@"C:\Log.txt");  
         TextStream.WriteLine("This  Log was created on {0}", DateTime.Now);  
         TextStream.Close();  
      }  
   }  
}   

I frammenti di codice seguenti mostrano la sintassi imperativa per l'override dei controlli di sicurezza tramite il metodo Assert .The following code fragments show imperative syntax for overriding security checks using the Assert method. In questo esempio viene dichiarata un'istanza dell'oggetto FileIOPermission .In this example, an instance of the FileIOPermission object is declared. Al costruttore viene passato FileIOPermissionAccess. AllAccess per definire il tipo di accesso consentito, seguito da una stringa che descrive la posizione del file.Its constructor is passed FileIOPermissionAccess.AllAccess to define the type of access allowed, followed by a string describing the file's location. Una volta definito l'oggetto FileIOPermission , è sufficiente chiamare il relativo metodo Assert per eseguire l'override del controllo di sicurezza.Once the FileIOPermission object is defined, you only need to call its Assert method to override the security check.

Option Explicit  
Option Strict  
Imports System  
Imports System.IO  
Imports System.Security.Permissions  
Namespace LogUtil  
   Public Class Log  
      Public Sub New()  
      End Sub 'New  
  
      Public Sub MakeLog()  
         Dim FilePermission As New FileIOPermission(FileIOPermissionAccess.AllAccess, "C:\Log.txt")  
         FilePermission.Assert()  
         Dim TextStream As New StreamWriter("C:\Log.txt")  
         TextStream.WriteLine("This  Log was created on {0}", DateTime.Now)  
         TextStream.Close()  
      End Sub  
   End Class  
End Namespace  
namespace LogUtil  
{  
   using System;  
   using System.IO;  
   using System.Security.Permissions;  
  
   public class Log  
   {  
      public Log()  
      {      
      }     
      public void MakeLog()  
      {  
         FileIOPermission FilePermission = new FileIOPermission(FileIOPermissionAccess.AllAccess,@"C:\Log.txt");   
         FilePermission.Assert();  
         StreamWriter TextStream = new StreamWriter(@"C:\Log.txt");  
         TextStream.WriteLine("This  Log was created on {0}", DateTime.Now);  
         TextStream.Close();  
      }  
   }  
}  

Vedere ancheSee also