Partilhar via

Principais conceitos de segurança

Observação

Este artigo aplica-se ao Windows.

Para obter informações sobre o ASP.NET Core, consulte Visão geral do ASP.NET Core Security.

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

Tipo de segurança e proteção

O código Type-Safe acessa apenas os locais de memória que 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 aspeto mais amplo.) Por exemplo, o código type-safe não pode ler valores de campos privados de outro objeto. Ele acessa tipos apenas de maneiras bem definidas e permitidas.

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

Embora a verificação da segurança de tipos não seja obrigatória para executar código gerido, a segurança de tipos é fundamental para o isolamento de assemblies e para a aplicação de medidas de segurança. Quando o código é tipo seguro, o common language runtime pode isolar completamente os assemblies uns dos outros. Esse isolamento ajuda a garantir que os assemblies não possam afetar negativamente uns aos outros e aumenta a confiabilidade do aplicativo. Os componentes com segurança de tipo podem ser executados com segurança no mesmo processo, mesmo que sejam confiáveis em níveis diferentes. Quando o código não é tipado de forma segura, podem ocorrer efeitos colaterais indesejados. Por exemplo, o tempo de execução não pode impedir que o código gerenciado chame o código nativo (não gerenciado) e execute operações maliciosas. Quando o código é seguro quanto ao tipo, o mecanismo de imposição de segurança do tempo de execução garante que ele não acesse o código nativo, a menos que tenha permissão para fazê-lo. Todo o código que não é tipo seguro deve ter sido concedido SecurityPermission com o membro SkipVerification enum passado para ser executado.

Observação

O CAS (Code Access Security) foi preterido em todas as versões do .NET Framework e do .NET. As versões recentes do .NET não respeitam as anotações do CAS e produzem erros se as APIs relacionadas ao CAS forem usadas. Os desenvolvedores devem procurar meios alternativos de realizar tarefas de segurança.

Diretor

Um principal representa a identidade e a função de um utilizador e age em nome do utilizador. A segurança baseada em função no .NET oferece suporte a três tipos de principais:

  • As entidades genéricas representam usuários e funções que existem independentemente dos usuários e funções do Windows.

  • Os perfis do Windows representam os utilizadores do Windows e os seus papéis (ou os seus grupos do Windows). Uma entidade principal no Windows pode assumir a identidade de outro usuário, o que significa que pode acessar um recurso em nome desse usuário enquanto apresenta a identidade que lhe pertence.

  • Os principais personalizados podem ser definidos por uma aplicação de qualquer forma que seja necessária para essa aplicação específica. Podem expandir a noção básica da identidade e das funções do responsável.

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 uma pessoa, examinando as credenciais do utilizador e validando essas credenciais junto de uma autoridade confiável. 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 responsável aceda ao seu código. Consulte as sobrecargas do método WindowsPrincipal.IsInRole para obter exemplos de como autenticar o principal para roles específicas. 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 atualmente, muitos dos quais podem ser usados com segurança baseada em função .NET. Alguns dos mecanismos mais usados são básico, digest, Passport, sistema operacional (como NTLM ou Kerberos) ou mecanismos definidos pelo aplicativo.

Exemplo

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

Observação

No Windows Vista, o Controle de Conta de Usuário (UAC) determina os privilégios de um usuário. Se você for membro do grupo Administradores internos, receberá dois tokens de acesso em tempo de execução: um token de acesso de usuário padrão e um token de acesso de administrador. Por padrão, você está na função de usuário padrão. Para executar o código que requer que você seja um administrador, você deve primeiro elevar seus privilégios de usuário padrão para administrador. Você pode fazer isso ao iniciar um aplicativo clicando com o botão direito do mouse no ícone do aplicativo e indicando que deseja executar como administrador.

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 as funções disponíveis para o principal. Uma aplicação deste exemplo pode ser confirmar que o utilizador atual está num papel que você permite para usar a sua aplicação.

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 determinar se uma entidade está autorizada a 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 principal para determinar quais recursos o principal pode acessar. Você pode usar a segurança baseada em função do .NET para implementar a autorização.

Ver também