Główne pojęcia dotyczące zabezpieczeń

Uwaga

Ten artykuł dotyczy Windows.

Aby uzyskać informacje o ASP.NET Core, zobacz Omówienie zabezpieczeń ASP.NET Core.

Platforma .NET oferuje zabezpieczenia oparte na rolach, aby pomóc w rozwiązywaniu problemów z zabezpieczeniami dotyczących kodu mobilnego i zapewnianiu pomocy technicznej, która umożliwia składnikom określenie, do czego użytkownicy mają uprawnienia.

Bezpieczeństwo i zabezpieczenia typów

Kod bezpieczny pod kątem typów uzyskuje dostęp tylko do lokalizacji pamięci, do których ma dostęp. (Na potrzeby tej dyskusji bezpieczeństwo typów odnosi się konkretnie do bezpieczeństwa typu pamięci i nie należy mylić z bezpieczeństwem typów w szerszym zakresie). Na przykład kod bezpieczny pod kątem typów nie może odczytywać wartości z pól prywatnych innego obiektu. Uzyskuje dostęp do typów tylko w dobrze zdefiniowanych, dozwolonych sposobach.

Podczas kompilacji typu just in time (JIT) opcjonalny proces weryfikacji sprawdza metadane i język pośredni firmy Microsoft (MSIL) metody, która ma być kompilowana w natywnym kodzie maszynowym w celu sprawdzenia, czy są one bezpieczne. Ten proces jest pomijany, jeśli kod ma uprawnienia do obejścia weryfikacji. Aby uzyskać więcej informacji na temat weryfikacji, zobacz Proces wykonywania zarządzanego.

Mimo że weryfikacja bezpieczeństwa typu nie jest obowiązkowa do uruchamiania kodu zarządzanego, bezpieczeństwo typu odgrywa kluczową rolę w izolacji zestawów i wymuszaniu zabezpieczeń. Gdy kod jest bezpieczny, środowisko uruchomieniowe języka wspólnego może całkowicie odizolować zestawy od siebie. Ta izolacja pomaga zapewnić, że zestawy nie mogą negatywnie wpływać na siebie i zwiększa niezawodność aplikacji. Składniki bezpieczne dla typów mogą być bezpiecznie wykonywane w tym samym procesie, nawet jeśli są zaufane na różnych poziomach. Gdy kod nie jest bezpieczny, mogą wystąpić niepożądane skutki uboczne. Na przykład środowisko uruchomieniowe nie może uniemożliwić zarządzanemu kodowi wywoływania kodu natywnego (niezarządzanego) i wykonywania złośliwych operacji. Gdy kod jest bezpieczny dla typu, mechanizm wymuszania zabezpieczeń środowiska uruchomieniowego zapewnia, że nie uzyskuje dostępu do kodu natywnego, chyba że ma do tego uprawnienia. Aby można było uruchomić cały kod, który nie jest typem bezpieczny, musi zostać udzielony SecurityPermission z przekazanym elementem wyliczeniowym SkipVerification .

Uwaga

Zabezpieczenia dostępu kodu (CAS) zostały uznane za przestarzałe we wszystkich wersjach .NET Framework i .NET. Najnowsze wersje platformy .NET nie honorują adnotacji CAS i generują błędy, jeśli są używane interfejsy API związane z usługą CAS. Deweloperzy powinni szukać alternatywnych sposobów wykonywania zadań zabezpieczeń.

Główne

Podmiot zabezpieczeń reprezentuje tożsamość i rolę użytkownika i działa w imieniu użytkownika. Zabezpieczenia oparte na rolach na platformie .NET obsługują trzy rodzaje podmiotów zabezpieczeń:

  • Ogólne podmioty zabezpieczeń reprezentują użytkowników i role, które istnieją niezależnie od Windows użytkowników i ról.

  • Windows podmioty zabezpieczeń reprezentują użytkowników Windows i ich role (lub ich grupy Windows). Podmiot zabezpieczeń Windows może personifikować innego użytkownika, co oznacza, że podmiot zabezpieczeń może uzyskać dostęp do zasobu w imieniu użytkownika podczas prezentowania tożsamości, która należy do tego użytkownika.

  • Niestandardowe podmioty zabezpieczeń mogą być definiowane przez aplikację w dowolny sposób, który jest wymagany dla tej konkretnej aplikacji. Mogą rozszerzyć podstawowe pojęcie tożsamości i ról podmiotu zabezpieczeń.

Aby uzyskać więcej informacji, zobacz Obiekty podmiotu zabezpieczeń i tożsamości.

Authentication

Uwierzytelnianie to proces odnajdywania i weryfikowania tożsamości podmiotu zabezpieczeń przez sprawdzenie poświadczeń użytkownika i zweryfikowanie tych poświadczeń względem określonego urzędu. Informacje uzyskane podczas uwierzytelniania są bezpośrednio używane przez kod. Możesz również użyć zabezpieczeń opartych na rolach platformy .NET, aby uwierzytelnić bieżącego użytkownika i określić, czy zezwolić tej jednostce na dostęp do kodu. Zobacz przeciążenia metody , WindowsPrincipal.IsInRole aby zapoznać się z przykładami sposobu uwierzytelniania podmiotu zabezpieczeń dla określonych ról. Na przykład można użyć WindowsPrincipal.IsInRole(String) przeciążenia, aby określić, czy bieżący użytkownik jest członkiem grupy Administratorzy.

Obecnie jest używanych wiele różnych mechanizmów uwierzytelniania, z których wiele może być używanych z zabezpieczeniami opartymi na rolach platformy .NET. Niektóre z najczęściej używanych mechanizmów to podstawowe, szyfrowane, passport, system operacyjny (np. NTLM lub Kerberos) lub mechanizmy zdefiniowane przez aplikację.

Przykład

Poniższy przykład wymaga, aby aktywny podmiot zabezpieczeń był administratorem. Parametr name to null, który umożliwia każdemu użytkownikowi, który jest administratorem, może przekazać żądanie.

Uwaga

W Windows Vista kontrola konta użytkownika (UAC) określa uprawnienia użytkownika. Jeśli jesteś członkiem wbudowanej grupy Administratorzy, masz przypisane dwa tokeny dostępu w czasie wykonywania: token dostępu użytkownika standardowego i token dostępu administratora. Domyślnie jesteś w roli użytkownika standardowego. Aby wykonać kod, który wymaga uprawnień administratora, musisz najpierw podnieść swoje uprawnienia od użytkownika standardowego do administratora. Możesz to zrobić po uruchomieniu aplikacji, klikając prawym przyciskiem myszy ikonę aplikacji i wskazując, że chcesz uruchomić jako 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
End Class

W poniższym przykładzie pokazano, jak określić tożsamość podmiotu zabezpieczeń i role dostępne dla podmiotu zabezpieczeń. Zastosowaniem tego przykładu może być potwierdzenie, że bieżący użytkownik znajduje się w roli, którą zezwalasz na korzystanie z aplikacji.

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

    Public Shared Sub Main()
        DemonstrateWindowsBuiltInRoleEnum()

    End Sub
End Class

Autoryzacja

Autoryzacja to proces określania, czy podmiot zabezpieczeń może wykonać żądaną akcję. Autoryzacja następuje po uwierzytelnieniu i używa informacji o tożsamości i rolach podmiotu zabezpieczeń w celu określenia zasobów, do których podmiot zabezpieczeń może uzyskać dostęp. Do zaimplementowania autoryzacji można użyć zabezpieczeń opartych na rolach platformy .NET.

Zobacz też