Conceitos principais de segurança
Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Conceitos principais de segurança

 

O Microsoft .NET Framework oferece segurança baseada em função para ajudar a resolver problemas de segurança sobre código móvel e fornecer suporte que permite que componentes para determinar quais usuários estão autorizados a fazer.

Código fortemente tipado acessa apenas os locais de memória que ele está autorizado a acessar. (Para esta discussão, segurança de tipos especificamente refere-se a segurança de tipo de memória e não deve ser confundida com segurança de tipos em um sentido mais amplo.) Por exemplo, código fortemente tipado não é possível ler valores de campos privados de outro objeto. Ele acessa tipos somente em modos permitidos e bem definidos.

Durante a compilação just-in-time (JIT), um processo de verificação opcional examina os metadados e Microsoft intermediate language (MSIL) de um método para ser compilado por JIT em código nativo da máquina para verificar se eles são fortemente tipado. Esse processo será ignorado se o código tem permissão para ignorar essa verificação. Para obter mais informações sobre a verificação, consulte Processo de execução gerenciada.

Embora a verificação de segurança de tipo não é obrigatória para executar código gerenciado, a segurança de tipo desempenha um papel fundamental na imposição de segurança e isolamento do assembly. Quando o código é fortemente tipado, o common language runtime pode isolar completamente assemblies uns dos outros. Esse isolamento ajuda a garantir que os assemblies não afetem uns aos outros e aumenta a confiabilidade do aplicativo. Componentes de segurança de tipos podem executar com segurança no mesmo processo mesmo que ele é confiável em níveis diferentes. Quando o código não é fortemente tipado, efeitos colaterais indesejados podem ocorrer. Por exemplo, o tempo de execução não pode impedir que o código gerenciado chamar código nativo (não gerenciado) e executar operações mal-intencionadas. Quando o código é fortemente tipado, o mecanismo de imposição de segurança do tempo de execução garante que ele não acessar o código nativo, a menos que ele tenha permissão para fazer isso. Todo o código que não é do tipo seguro deve ser concedido SecurityPermission com o membro enum passado SkipVerification para executar.

Para obter mais informações, consulte Code Access Security Basics.

Uma entidade de segurança representa a identidade e a função de um usuário e atua em nome do usuário. Segurança baseada em função no .NET Framework oferece suporte a três tipos de entidades:

  • Objetos genéricos representam usuários e funções que existem independentes de funções e usuários do Windows.

  • Entidades de segurança do Windows representam usuários do Windows e suas funções (ou seus grupos do Windows). Uma entidade de segurança do Windows pode representar outro usuário, o que significa que a entidade de segurança pode acessar um recurso em um nome de usuário enquanto apresentar a identidade que pertence a esse usuário.

  • As entidades personalizadas podem ser definidas por um aplicativo de qualquer forma que é necessária para o aplicativo específico. Eles podem estender a noção básica de identidade e funções do servidor principal.

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

Autenticação é o processo de detecção e verificar a identidade de um objeto examinando as credenciais do usuário e validar essas credenciais em alguma autoridade. As informações obtidas durante a autenticação serão diretamente utilizáveis pelo seu código. Você também pode usar segurança baseada em função do .NET Framework para autenticar o usuário atual e para determinar se deve permitir principal acessar o seu código. Consulte as sobrecargas do WindowsPrincipal.IsInRole método para obter exemplos de como autenticar a entidade de segurança para funções específicas. Por exemplo, você pode usar o 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 do .NET Framework. Alguns dos mecanismos mais comumente usados são basic, digest, Passport, sistema operacional (como NTLM ou Kerberos) ou mecanismos definidos pelo aplicativo.

O exemplo a seguir exige que a entidade de segurança ativa seja um administrador. O name parâmetro é null, que permite que qualquer usuário que seja um administrador para passar a demanda.

System_CAPS_noteObservação

No Windows Vista, o controle de conta de usuário (UAC) determina os privilégios de um usuário. Se você for um membro do grupo Administradores internos, recebem dois tokens de acesso de 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 você deve ser um administrador, você deve primeiro elevar os privilégios de usuário padrão ao administrador. Você pode fazer isso quando você iniciar um aplicativo clicando duas vezes no ícone do aplicativo e que indica que você 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.");
    }
}

O exemplo a seguir demonstra como determinar a identidade do principal e as funções disponíveis para a entidade de segurança. Um aplicativo deste exemplo pode ser confirmar se o usuário atual está em uma função que permite o uso de 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("{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();
    }
}

Autorização é o processo de determinar se uma entidade tem permissão para executar uma ação solicitada. Autorização ocorre após a autenticação e usa as informações sobre as funções e a identidade da entidade de segurança para determinar quais recursos pode acessar a entidade de segurança. Você pode usar a segurança baseada em função do .NET Framework para implementar a autorização.

Mostrar:
© 2016 Microsoft