Viktiga säkerhetsbegrepp

.NET erbjuder rollbaserad säkerhet för att hjälpa till att hantera säkerhetsproblem med mobilkod och för att ge stöd som gör det möjligt för komponenter att avgöra vad användarna har behörighet att göra.

Typsäkerhet och säkerhet

Typsäker kod får endast åtkomst till de minnesplatser som den har behörighet att komma åt. (För denna diskussion avser typsäkerhet specifikt minnestypsäkerhet och bör inte förväxlas med typsäkerhet i ett bredare avseende.) Till exempel kan inte typsäker kod läsa värden från ett annat objekts privata fält. Den kommer endast åt typer på väldefinierade och tillåtna sätt.

Under processen för just-in-time-kompilering undersöker en valfri verifieringsprocess metadata och det gemensamma intermediära språket (CIL) för en metod som ska JIT-kompileras till infödd maskinkod för att verifiera att de är typ-säkra. Den här processen utelämnas om koden har behörighet att kringgå verifieringen. Mer information om verifiering finns i Hanterad körningsprocess.

Även om verifiering av typsäkerhet inte är obligatorisk för att köra hanterad kod spelar typsäkerhet en avgörande roll vid monteringsisolering och säkerhetstillämpning. När koden är typsäker kan Common Language Runtime (CLR) helt isolera assembly-komponenter från varandra. Den här isoleringen hjälper till att säkerställa att sammansättningar inte kan påverka varandra negativt och öka programmets tillförlitlighet. Typsäkra komponenter kan köras säkert i samma process även om de är betrodda på olika nivåer. När koden inte är typsäker kan oönskade biverkningar uppstå. Körningstiden kan till exempel inte förhindra hanterad kod från att anropa nativ (ohanterad) kod och utföra skadliga åtgärder. När koden är typsäker ser körmiljöns säkerhetssystem till att den inte får åtkomst till nativer kod utan behörighet. All kod som inte är typsäker måste ha beviljats SecurityPermission med den skickade uppräkningsmedlemmen SkipVerification för att köras.

Rektor

En huvudansvarig representerar en användares identitet och roll och agerar på användarens vägnar. Rollbaserad säkerhet i .NET stöder tre typer av principaler:

• Allmänna huvudnamn representerar användare och roller som finns oberoende av Windows-användare och roller.

• Windows-huvudnamn representerar Windows-användare och deras roller (eller deras Windows-grupper). En Windows-principal kan imitera en annan användare, vilket innebär att principalen kan komma åt en resurs på uppdrag av en användare med användarens identitet.

• Anpassade principaler kan definieras av en applikation på alla sätt som behövs för just den applikationen. De kan utöka det grundläggande begreppet om huvudmannens identitet och roller.

Mer information finns i Huvudobjekt och Identitetsobjekt.

Autentisering

Autentisering är processen att upptäcka och verifiera identiteten för en huvudperson genom att undersöka användarens autentiseringsuppgifter och validera dessa autentiseringsuppgifter mot en myndighet. Den information som erhålls under autentiseringen kan användas direkt av din kod. Du kan också använda rollbaserad .NET-säkerhet för att autentisera den aktuella användaren och för att avgöra om du vill tillåta att huvudkontot får åtkomst till koden. Se överlagringarna av metoden WindowsPrincipal.IsInRole för exempel på hur huvudmannen autentiseras för specifika roller. Du kan till exempel använda WindowsPrincipal.IsInRole(String)-överbelastning för att avgöra om den aktuella användaren är en medlem i Administratörer-gruppen.

En mängd olika autentiseringsmekanismer används idag, varav många kan användas med rollbaserad säkerhet i .NET. Några av de vanligaste mekanismerna är grundläggande, sammanfattade, Passport, operativsystem (till exempel NTLM eller Kerberos) eller programdefinierade mekanismer.

Exempel

I följande exempel krävs att den aktiva huvudprincipalen är administratör. Parametern name är null, som gör det möjligt för alla användare som är administratörer att uppfylla kravet.

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

I följande exempel visas hur du identifierar identiteten för huvudmannen och de roller som finns tillgängliga för huvudmannen. Ett program i det här exemplet kan vara att bekräfta att den aktuella användaren är i en roll som du tillåter för att använda ditt program.

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

Auktorisering

Auktorisering är processen att avgöra om en användare har tillåtelse att utföra en begärd åtgärd. Auktorisering sker efter autentisering och använder information om huvudpersonens identitet och roller för att avgöra de resurser som huvudpersonen kan komma åt. Du kan använda rollbaserad säkerhet i .NET för att implementera auktorisering.

Se även

• ASP.NET Core Security