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 consentire al codice (e ai chiamanti downstream) eseguire azioni che il codice dispone delle autorizzazioni, ma i chiamanti non dispone dell'autorizzazione necessaria.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 codice non gestito deve avere SecurityPermission con il UnmanagedCode flag 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. Perché gli sviluppatori che usano la libreria non hanno accesso all'origine, non hanno modo di sapere che è necessaria il RegistryPermission per 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 questo caso, è appropriato per la raccolta per l'asserzione dell'autorizzazione, che i chiamanti privi RegistryPermission possono utilizzare 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. Ad esempio, se si effettua un'asserzione FileIOPermission viene effettuata per leggere tutti i file sull'unità C e una richiesta downstream FileIOPermission per leggere i file in C:\Temp, l'asserzione può influire sull'analisi dello stack. Tuttavia, se la richiesta era per FileIOPermission per scrivere sull'unità C, l'asserzione non avrà 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 mostra 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 FileIOPermission tipi 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.


Uso di AssertUsing Assert

In questo scenario, il metodo a chiama B, B chiama C, C chiama E ed E chiama F. metodo C effettua un'asserzione dell'autorizzazione per leggere i file nell'unità C (autorizzazione P1) e metodo E richiede l'autorizzazione per leggere i file con estensione txt presenti 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 la richiesta in F viene rilevata in fase di esecuzione, viene eseguita un'analisi dello stack per controllare le autorizzazioni di tutti i chiamanti di F, a partire da E. E dispone dell'autorizzazione P1A, pertanto il percorso stack procede esaminando le autorizzazioni di C, in cui 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 quindi un'operazione per cui si conosce la maggior parte dei chiamanti non disporrà dell'autorizzazione e se si è disposti a responsabilità per consentire ai chiamanti di chiamare il codice, è possibile dichiarare l'autorizzazione chiamando il Assert metodo su un oggetto di autorizzazione che rappresenta l'operazione che sta eseguendo il 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. Utilizzando Assert in questo modo consente i chiamanti che normalmente non disporrebbero chiamare il 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 codice eliminare , 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 di eliminare il metodo, il codice crea un FileIOPermission 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 FileIOPermission dell'oggetto richiesta metodo.(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 disporrà dell'autorizzazione per accedere al codice non gestito, il codice crea quindi un SecurityPermission oggetto che rappresenta il diritto di chiamare codice non gestito e chiama l'oggetto Assert metodo.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, si potrebbe non effettua un'asserzione di FileIOPermission per la scrittura di file perché il codice sarebbe esposto a uso 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 utilizza la sintassi imperativa, chiamando la Assert metodo su più autorizzazioni nello stesso metodo fa sì che venga generata 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. In alternativa, è necessario creare un PermissionSet dell'oggetto e passare a tale oggetto le singole autorizzazioni che si desidera richiamare e quindi chiamare il Assert metodo il PermissionSet oggetto.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 Assert metodo più volte quando si utilizza la sintassi di sicurezza dichiarativa.You can call the Assert method more than once when you use the declarative security syntax.

L'esempio seguente mostra la sintassi dichiarativa per sicurezza esegue l'override dei controlli mediante il Assert metodo.The following example shows declarative syntax for overriding security checks using the Assert method. Si noti che il FileIOPermissionAttribute sintassi accetta due valori: una SecurityAction enumerazione e la posizione del file o della directory a cui viene 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 fa sì che le richieste per l'accesso a C:\Log.txt abbia esito positivo, anche se i chiamanti non vengono controllati per l'autorizzazione accedere al file.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 seguente mostrano la sintassi imperativa per sicurezza esegue l'override dei controlli mediante il Assert metodo.The following code fragments show imperative syntax for overriding security checks using the Assert method. In questo esempio, un'istanza di FileIOPermission a un oggetto dichiarato.In this example, an instance of the FileIOPermission object is declared. Viene passato al costruttore FileIOPermissionAccess. AllAccess per definire il tipo di accesso consentito, seguito da una stringa che descrive il percorso 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 il FileIOPermission oggetto è definito, è necessario chiamare il relativo Assert 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

PermissionSet
SecurityPermission
FileIOPermission
SecurityAction
AttributiAttributes
Sicurezza dall'accesso di codiceCode Access Security