Concetti principali sulla sicurezzaKey Security Concepts

Microsoft .NET Framework offre la sicurezza basata sui ruoli per risolvere i problemi di sicurezza relativi al codice mobile e per fornire un supporto che consenta di abilitare i componenti per determinare le operazioni per cui gli utenti dispongono di autorizzazioni.The Microsoft .NET Framework offers role-based security to help address security concerns about mobile code and to provide support that enables components to determine what users are authorized to do.

Indipendenza dai tipi e sicurezzaType safety and security

Il codice indipendente dai tipi accede solo alle posizioni di memoria per le quali dispone di autorizzazioni.Type-safe code accesses only the memory locations it is authorized to access. In questo contesto, per indipendenza dai tipi si intende l'indipendenza dai tipi di memoria, che non deve essere confusa con il concetto più generico di indipendenza dai tipi. Ad esempio, un codice indipendente dai tipi non può leggere i valori dei campi privati di un altro oggetto.(For this discussion, type safety specifically refers to memory type safety and should not be confused with type safety in a broader respect.) For example, type-safe code cannot read values from another object's private fields. Accede ai tipi solo in modalità ben definite e consentite.It accesses types only in well-defined, allowable ways.

Durante la compilazione Just-In-Time (JIT), un processo di verifica facoltativo esamina i metadati e MSIL (Microsoft Intermediate Language) di un metodo su cui eseguire la compilazione JIT in codice macchina nativo per verificare che siano indipendenti dai tipi.During just-in-time (JIT) compilation, an optional verification process examines the metadata and Microsoft intermediate language (MSIL) of a method to be JIT-compiled into native machine code to verify that they are type safe. Questo processo viene ignorato se il codice dispone dell'autorizzazione per ignorare la verifica.This process is skipped if the code has permission to bypass verification. Per altre informazioni sulla verifica, vedere Processo di esecuzione gestita.For more information about verification, see Managed Execution Process.

Sebbene la verifica dell'indipendenza dai tipi non sia obbligatoria per l'esecuzione di codice gestito, l'indipendenza dai tipi ha un ruolo fondamentale nell'imposizione della sicurezza e nell'isolamento dell'assembly.Although verification of type safety is not mandatory to run managed code, type safety plays a crucial role in assembly isolation and security enforcement. Quando il codice è indipendente dai tipi, Common Language Runtime può isolare completamente i singoli assembly.When code is type safe, the common language runtime can completely isolate assemblies from each other. Questo isolamento contribuisce a garantire che gli assembly non interferiscano tra loro, aumentando l'affidabilità dell'applicazione.This isolation helps ensure that assemblies cannot adversely affect each other and it increases application reliability. I componenti indipendenti dai tipi possono essere eseguiti in modo sicuro nello stesso processo anche se sono attendibili a livelli diversi.Type-safe components can execute safely in the same process even if they are trusted at different levels. Quando il codice non è indipendente dai tipi possono verificarsi effetti collaterali indesiderati.When code is not type safe, unwanted side effects can occur. Il runtime, ad esempio, non è in grado di impedire al codice gestito di effettuare chiamate a codice nativo (non gestito) e di eseguire operazioni dannose.For example, the runtime cannot prevent managed code from calling into native (unmanaged) code and performing malicious operations. Quando il codice è indipendente dai tipi, il meccanismo di imposizione della sicurezza del runtime ne impedisce l'accesso al codice nativo a meno che non disponga delle autorizzazioni.When code is type safe, the runtime's security enforcement mechanism ensures that it does not access native code unless it has permission to do so. Per essere eseguito, tutto il codice non indipendente dai tipi deve aver ottenuto SecurityPermission con il membro di enumerazione passato SkipVerification.All code that is not type safe must have been granted SecurityPermission with the passed enum member SkipVerification to run.

Per altre informazioni, vedere Code Access Security Basics (Nozioni di base sulla sicurezza dell'accesso di codice).For more information, see Code Access Security Basics.

PrincipalPrincipal

Un'entità rappresenta l'identità e il ruolo di un utente e agisce per conto dell'utente.A principal represents the identity and role of a user and acts on the user's behalf. La sicurezza basata sui ruoli in .NET Framework supporta tre tipi di entità:Role-based security in the .NET Framework supports three kinds of principals:

  • Le entità generiche rappresentano utenti e ruoli che esistono indipendentemente dai ruoli e dagli utenti di Windows.Generic principals represent users and roles that exist independent of Windows users and roles.

  • Le entità di Windows rappresentano gli utenti di Windows e i relativi ruoli (o i gruppi di Windows).Windows principals represent Windows users and their roles (or their Windows groups). Un'entità di Windows può rappresentare un altro utente, il che significa che l'entità può accedere a una risorsa per conto dell'utente presentando l'identità appartenente a tale utente.A Windows principal can impersonate another user, which means that the principal can access a resource on a user's behalf while presenting the identity that belongs to that user.

  • Le entità personalizzate possono essere definite da un'applicazione secondo le modalità richieste dalla specifica applicazione.Custom principals can be defined by an application in any way that is needed for that particular application. Possono estendere la nozione di base di identità e di ruoli dell'entità.They can extend the basic notion of the principal's identity and roles.

Per altre informazioni, vedere Oggetti Principal e Identity.For more information, see Principal and Identity Objects.

AuthenticationAuthentication

L'autenticazione è il processo di individuazione e verifica dell'identità di un'entità eseguito esaminando e convalidando le credenziali dell'utente rispetto a un'autorità specificata.Authentication is the process of discovering and verifying the identity of a principal by examining the user's credentials and validating those credentials against some authority. Le informazioni ottenute durante l'autenticazione possono essere usate direttamente dal codice.The information obtained during authentication is directly usable by your code. È anche possibile usare la sicurezza basata sui ruoli di .NET Framework per autenticare l'utente corrente e per determinare se consentire a tale entità di accedere al codice.You can also use .NET Framework role-based security to authenticate the current user and to determine whether to allow that principal to access your code. Vedere gli overload del metodo WindowsPrincipal.IsInRole per esempi su come autenticare l'entità per ruoli specifici.See the overloads of the WindowsPrincipal.IsInRole method for examples of how to authenticate the principal for specific roles. Ad esempio, è possibile usare l'overload WindowsPrincipal.IsInRole(String) per determinare se l'utente corrente è un membro del gruppo Administrators.For example, you can use the WindowsPrincipal.IsInRole(String) overload to determine if the current user is a member of the Administrators group.

Un'ampia gamma di meccanismi di autenticazione usati oggi, molti dei quali possono essere usati con la sicurezza basata sui ruoli di .NET Framework.A variety of authentication mechanisms are used today, many of which can be used with .NET Framework role-based security. Alcuni dei meccanismi più diffusi sono il meccanismo di base, il digest, il Passport, il sistema operativo (ad esempio NTLM o Kerberos) o i meccanismi definiti dall'applicazione.Some of the most commonly used mechanisms are basic, digest, Passport, operating system (such as NTLM or Kerberos), or application-defined mechanisms.

EsempioExample

L'esempio seguente richiede che l'entità attiva sia un amministratore.The following example requires that the active principal be an administrator. Il parametro name è null, che consente a qualsiasi utente con ruolo di amministratore di passare la richiesta.The name parameter is null, which allows any user who is an administrator to pass the demand.

Nota

In Windows Vista, la funzionalità Controllo dell'account utente determina i privilegi di un utente.In Windows Vista, User Account Control (UAC) determines the privileges of a user. Ai membri del gruppo Administrators predefinito vengono assegnati due token di accesso in fase di esecuzione, ovvero un token di accesso utente standard e un token di accesso amministratore.If you are a member of the Built-in Administrators group, you are assigned two run-time access tokens: a standard user access token and an administrator access token. Per impostazione predefinita, viene assegnato il ruolo dell'utente standard.By default, you are in the standard user role. Per eseguire il codice che richiede un ruolo da amministratore è necessario elevare i privilegi da utente standard ad amministratore.To execute the code that requires you to be an administrator, you must first elevate your privileges from standard user to administrator. È possibile farlo quando si avvia un'applicazione facendo clic con il pulsante destro del mouse sull'icona dell'applicazione e indicando l'opzione di esecuzione come amministratore.You can do this when you start an application by right-clicking the application icon and indicating that you want to run as an administrator.

using namespace System;
using namespace System::Security;
using namespace System::Security::Permissions;
using namespace System::Security::Policy;
using namespace System::Security::Principal;

int main(array<System::String ^> ^args)
{
    System::String^ null;
    AppDomain::CurrentDomain->SetPrincipalPolicy(PrincipalPolicy::WindowsPrincipal);
    PrincipalPermission^ principalPerm = gcnew PrincipalPermission(null, "Administrators" );
      principalPerm->Demand();
      Console::WriteLine("Demand succeeded");
    return 0;
}
using System;
using System.Threading;
using System.Security.Permissions;
using System.Security.Principal;

class SecurityPrincipalDemo
{

    public static void Main()
    {
        AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
        PrincipalPermission principalPerm = new PrincipalPermission(null, "Administrators");
        principalPerm.Demand();
        Console.WriteLine("Demand succeeded.");
    }
}
Imports System.Threading
Imports System.Security.Permissions
Imports System.Security.Principal



Class SecurityPrincipalDemo


    Public Shared Sub Main()
        AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal)
        Dim principalPerm As New PrincipalPermission(Nothing, "Administrators")
        principalPerm.Demand()
        Console.WriteLine("Demand succeeded.")

    End Sub 'Main
End Class 'SecurityPrincipalDemo

L'esempio seguente mostra come determinare l'identità dell'entità e i ruoli disponibili per l'entità.The following example demonstrates how to determine the identity of the principal and the roles available to the principal. Un'applicazione di questo esempio potrebbe essere la conferma che l'utente corrente ha un ruolo autorizzato all'uso dell'applicazione.An application of this example might be to confirm that the current user is in a role you allow for using your application.

public:
   static void DemonstrateWindowsBuiltInRoleEnum()
   {
      AppDomain^ myDomain = Thread::GetDomain();

      myDomain->SetPrincipalPolicy( PrincipalPolicy::WindowsPrincipal );
      WindowsPrincipal^ myPrincipal = dynamic_cast<WindowsPrincipal^>(Thread::CurrentPrincipal);

      Console::WriteLine( "{0} belongs to: ", myPrincipal->Identity->Name );

      Array^ wbirFields = Enum::GetValues( WindowsBuiltInRole::typeid );

      for each ( Object^ roleName in wbirFields )
      {
         try
         {
            Console::WriteLine( "{0}? {1}.", roleName,
               myPrincipal->IsInRole(  *dynamic_cast<WindowsBuiltInRole^>(roleName) ) );
         }
         catch ( Exception^ ) 
         {
            Console::WriteLine( "{0}: Could not obtain role for this RID.",
               roleName );
         }
      }
   }
using System;
using System.Threading;
using System.Security.Permissions;
using System.Security.Principal;

class SecurityPrincipalDemo
{
    public static void DemonstrateWindowsBuiltInRoleEnum()
    {
        AppDomain myDomain = Thread.GetDomain();

        myDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
        WindowsPrincipal myPrincipal = (WindowsPrincipal)Thread.CurrentPrincipal;
        Console.WriteLine("{0} belongs to: ", myPrincipal.Identity.Name.ToString());
        Array wbirFields = Enum.GetValues(typeof(WindowsBuiltInRole));
        foreach (object roleName in wbirFields)
        {
            try
            {
                // Cast the role name to a RID represented by the WindowsBuildInRole value.
                Console.WriteLine("{0}? {1}.", roleName,
                    myPrincipal.IsInRole((WindowsBuiltInRole)roleName));
                Console.WriteLine("The RID for this role is: " + ((int)roleName).ToString());

            }
            catch (Exception)
            {
                Console.WriteLine("{0}: Could not obtain role for this RID.",
                    roleName);
            }
        }
        // Get the role using the string value of the role.
        Console.WriteLine("{0}? {1}.", "Administrators",
            myPrincipal.IsInRole("BUILTIN\\" + "Administrators"));
        Console.WriteLine("{0}? {1}.", "Users",
            myPrincipal.IsInRole("BUILTIN\\" + "Users"));
        // Get the role using the WindowsBuiltInRole enumeration value.
        Console.WriteLine("{0}? {1}.", WindowsBuiltInRole.Administrator,
           myPrincipal.IsInRole(WindowsBuiltInRole.Administrator));
        // Get the role using the WellKnownSidType.
        SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
        Console.WriteLine("WellKnownSidType BuiltinAdministratorsSid  {0}? {1}.", sid.Value, myPrincipal.IsInRole(sid));
    }

    public static void Main()
    {
        DemonstrateWindowsBuiltInRoleEnum();
    }
}
Imports System.Threading
Imports System.Security.Permissions
Imports System.Security.Principal

Class SecurityPrincipalDemo

    Public Shared Sub DemonstrateWindowsBuiltInRoleEnum()
        Dim myDomain As AppDomain = Thread.GetDomain()

        myDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal)
        Dim myPrincipal As WindowsPrincipal = CType(Thread.CurrentPrincipal, WindowsPrincipal)
        Console.WriteLine("{0} belongs to: ", myPrincipal.Identity.Name.ToString())
        Dim wbirFields As Array = [Enum].GetValues(GetType(WindowsBuiltInRole))
        Dim roleName As Object
        For Each roleName In wbirFields
            Try
                ' Cast the role name to a RID represented by the WindowsBuildInRole value.
                Console.WriteLine("{0}? {1}.", roleName, myPrincipal.IsInRole(CType(roleName, WindowsBuiltInRole)))
                Console.WriteLine("The RID for this role is: " + Fix(roleName).ToString())

            Catch
                Console.WriteLine("{0}: Could not obtain role for this RID.", roleName)
            End Try
        Next roleName
        ' Get the role using the string value of the role.
        Console.WriteLine("{0}? {1}.", "Administrators", myPrincipal.IsInRole("BUILTIN\" + "Administrators"))
        Console.WriteLine("{0}? {1}.", "Users", myPrincipal.IsInRole("BUILTIN\" + "Users"))
        ' Get the role using the WindowsBuiltInRole enumeration value.
        Console.WriteLine("{0}? {1}.", WindowsBuiltInRole.Administrator, myPrincipal.IsInRole(WindowsBuiltInRole.Administrator))
        ' Get the role using the WellKnownSidType.
        Dim sid As New SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, Nothing)
        Console.WriteLine("WellKnownSidType BuiltinAdministratorsSid  {0}? {1}.", sid.Value, myPrincipal.IsInRole(sid))

    End Sub 'DemonstrateWindowsBuiltInRoleEnum

    Public Shared Sub Main()
        DemonstrateWindowsBuiltInRoleEnum()

    End Sub 'Main
End Class 'SecurityPrincipalDemo 

AuthorizationAuthorization

L'autorizzazione è il processo che consente di determinare se un'entità è autorizzata a eseguire un'azione richiesta.Authorization is the process of determining whether a principal is allowed to perform a requested action. L'autorizzazione si verifica dopo l'autenticazione e usa le informazioni di identità e i ruoli dell'entità per determinare a quali risorse può accedere.Authorization occurs after authentication and uses information about the principal's identity and roles to determine what resources the principal can access. È possibile usare la sicurezza basata sui ruoli di .NET Framework per implementare l'autorizzazione.You can use .NET Framework role-based security to implement authorization.