Principais conceitos de segurança

O .NET oferece segurança baseada em função para ajudar a resolver preocupações de segurança sobre o código móvel e fornecer suporte que permite que os componentes determinem o que os usuários estão autorizados a fazer.

Segurança e segurança de tipos

O código de segurança de tipo acessa apenas os locais de memória que ele está autorizado a acessar. (Para esta discussão, a segurança do tipo refere-se especificamente à segurança do tipo de memória e não deve ser confundida com a segurança do tipo em um aspecto mais amplo.) Por exemplo, o código de tipo seguro não pode ler valores dos campos privados de outro objeto. Ele acessa tipos apenas de maneiras definidas e permitidas.

Durante a compilação just-in-time (JIT), um processo de verificação opcional examina os metadados e a linguagem intermediária comum (CIL) de um método a ser compilado em código de máquina nativo para verificar se eles são do tipo seguro. Esse processo será ignorado se o código tiver permissão para ignorar a verificação. Para obter mais informações sobre a verificação, consulte Processo de Execução Gerenciada.

Embora a verificação da segurança do tipo não seja obrigatória para executar o código gerenciado, a segurança do tipo desempenha um papel crucial no isolamento do assembly e na imposição de segurança. Quando o código é seguro de tipos, o ambiente de execução comum pode isolar completamente os assemblies uns dos outros. Esse isolamento ajuda a garantir que os componentes não influenciem negativamente uns aos outros e aumenta a confiabilidade da aplicação. Componentes de tipo seguro podem ser executados com segurança no mesmo processo, mesmo que sejam confiáveis em níveis diferentes. Quando o código não é tipo seguro, efeitos colaterais indesejados podem ocorrer. Por exemplo, o runtime não pode impedir que o código gerenciado chame o código nativo (não gerenciado) e execute operações mal-intencionadas. Quando o código é especificado como seguro, o mecanismo de segurança em tempo de execução garante que ele não acesse a um código nativo, a menos que tenha permissão para fazer isso. Todo o código que não é seguro de tipo deve ter sido concedido SecurityPermission com o membro de enumeração especificado SkipVerification para execução.

Entidade de segurança

Um principal representa a identidade e a função de um usuário e atua em nome do usuário. A segurança baseada em função no .NET dá suporte a três tipos de principais:

• Entidades de segurança genéricas representam usuários e funções que existem independentemente de usuários e funções do Windows.

• As principais do Windows representam usuários do Windows e suas funções (ou seus grupos do Windows). Um principal do Windows pode se passar por outro usuário, o que significa que o principal pode acessar um recurso em nome de um usuário ao apresentar a identidade que pertence a esse usuário.

• As principais personalizadas podem ser definidas por um aplicativo de qualquer maneira necessária para esse aplicativo específico. Eles podem ampliar a noção básica da identidade e dos papéis do principal.

Para obter mais informações, consulte Objetos Principal e de Identidade.

Autenticação

A autenticação é o processo de descobrir e verificar a identidade de um indivíduo examinando as credenciais do usuário e validando essas credenciais contra uma autoridade específica. As informações obtidas durante a autenticação são diretamente utilizáveis pelo seu código. Você também pode usar a segurança baseada em funções do .NET para autenticar o usuário atual e determinar se deve permitir que esse principal acesse seu código. Consulte as sobrecargas do método WindowsPrincipal.IsInRole para obter exemplos de como autenticar o principal para papéis específicos. Por exemplo, você pode usar a WindowsPrincipal.IsInRole(String) sobrecarga para determinar se o usuário atual é membro do grupo Administradores.

Uma variedade de mecanismos de autenticação são usados hoje, muitos dos quais podem ser usados com segurança baseada em função do .NET. Alguns dos mecanismos mais usados são mecanismos básicos, digest, Passport, sistema operacional (como NTLM ou Kerberos) ou mecanismos definidos pelo aplicativo.

Exemplo

O exemplo a seguir exige que o principal ativo seja um administrador. O name parâmetro é null, que permite que qualquer usuário que seja um administrador passe a demanda.

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
End Class

O exemplo a seguir demonstra como determinar a identidade do principal e os papéis disponíveis para o principal. Uma aplicação deste exemplo pode ser confirmar se o usuário atual está em uma função permitida para usar seu aplicativo.

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($"{myPrincipal.Identity.Name.ToString()} belongs to: ");
        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($"{roleName}? {myPrincipal.IsInRole((WindowsBuiltInRole)roleName)}.");
                Console.WriteLine("The RID for this role is: " + ((int)roleName).ToString());
            }
            catch (Exception)
            {
                Console.WriteLine($"{roleName}: Could not obtain role for this RID.");
            }
        }
        // Get the role using the string value of the role.
        Console.WriteLine($"'Administrators'? {myPrincipal.IsInRole("BUILTIN\\" + "Administrators")}.");
        Console.WriteLine($"'Users'? {myPrincipal.IsInRole("BUILTIN\\" + "Users")}.");
        // Get the role using the WindowsBuiltInRole enumeration value.
        Console.WriteLine($"{WindowsBuiltInRole.Administrator}? {myPrincipal.IsInRole(WindowsBuiltInRole.Administrator)}.");
        // Get the role using the WellKnownSidType.
        SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
        Console.WriteLine($"WellKnownSidType BuiltinAdministratorsSid  {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

    Public Shared Sub Main()
        DemonstrateWindowsBuiltInRoleEnum()

    End Sub
End Class

Autorização

A autorização é o processo de verificar se uma parte tem permissão para executar uma ação solicitada. A autorização ocorre após a autenticação e usa informações sobre a identidade e os papéis do usuário para determinar quais recursos o usuário pode acessar. Você pode usar a segurança baseada em função do .NET para implementar a autorização.

Consulte também

• segurança principal do ASP.NET