Delegering och maskering med WCF

Personifiering är en vanlig teknik som tjänster använder för att begränsa klientåtkomsten till en tjänstdomäns resurser. Tjänstdomänresurser kan antingen vara datorresurser, till exempel lokala filer (personifiering) eller en resurs på en annan dator, till exempel en filresurs (delegering). Ett exempelprogram finns i Personifiera klienten. Ett exempel på hur du använder personifiering finns i Så här: Personifiera en klient på en tjänst.

Översikt

Klienter anropar vanligtvis en tjänst för att låta tjänsten utföra vissa åtgärder för klientens räkning. Med personifiering kan tjänsten fungera som klient när åtgärden utförs. Genom delegering kan en front-end-tjänst vidarebefordra klientens begäran till en back-end-tjänst på ett sådant sätt att back-end-tjänsten också kan uppträda som klienten. Personifiering används oftast som ett sätt att kontrollera om en klient har behörighet att utföra en viss åtgärd, medan delegering är ett sätt att flöda personifieringsfunktioner, tillsammans med klientens identitet, till en serverdelstjänst. Delegering är en Windows-domänfunktion som kan användas när Kerberos-baserad autentisering utförs. Delegering skiljer sig från identitetsflödet och eftersom delegering överför möjligheten att personifiera klienten utan innehav av klientens lösenord är det en mycket högre privilegierad åtgärd än identitetsflödet.

Både personifiering och delegering kräver att klienten har en Windows-identitet. Om en klient inte har en Windows-identitet är det enda tillgängliga alternativet att skicka klientens identitet till den andra tjänsten.

Grunderna för imitation

Windows Communication Foundation (WCF) stöder personifiering för en mängd olika klientautentiseringsuppgifter. I det här avsnittet beskrivs stöd för tjänstmodell för att personifiera anroparen under implementeringen av en tjänstmetod. Här beskrivs också vanliga distributionsscenarier som omfattar personifiering och SOAP-säkerhet och WCF-alternativ i dessa scenarier.

Det här avsnittet fokuserar på personifiering och delegering i WCF när du använder SOAP-säkerhet. Du kan också använda personifiering och delegering med WCF när du använder transportsäkerhet, enligt beskrivningen i Använda personifiering med transportsäkerhet.

Två metoder

WCF SOAP-säkerhet har två olika metoder för att utföra personifiering. Vilken metod som används beror på bindningen. Den ena är personifiering från en Windows-token som hämtats från SSPI (Security Support Provider Interface) eller Kerberos-autentisering, som sedan cachelagras på tjänsten. Den andra är efterlikning från en Windows-token som erhållits från Kerberos-tilläggen, som tillsammans kallas Service-for-User (S4U).

Cacherad tokenpersonifiering

Du kan utföra cachelagrad token-personifiering med följande:

• WSHttpBinding, WSDualHttpBindingoch NetTcpBinding med en Windows-klientautentiseringsuppgift.

• BasicHttpBinding med en BasicHttpSecurityMode inställd på autentiseringsuppgiften TransportWithMessageCredential eller någon annan standardbindning där klienten presenterar ett användarnamn som tjänsten kan koppla till ett giltigt Windows-konto.

• Alla CustomBinding som använder en Windows-klientautentiseringsuppgift där requireCancellation är satt till true. (Egenskapen är tillgänglig i följande klasser: SecureConversationSecurityTokenParameters, SslSecurityTokenParameters, och SspiSecurityTokenParameters.) Om en säker konversation används på bindningen måste den också ha egenskapen requireCancellation inställd på true.

• Eventuella CustomBinding där klienten presenterar autentiseringsuppgifter för användarnamn. Om säker konversation används på bindningen, måste egenskapen också vara inställd på requireCancellationtrue.

S4U-Based Imitation

Du kan utföra S4U-baserad personifiering med följande:

• WSHttpBinding, WSDualHttpBinding, och NetTcpBinding med en certifikatklientautentiseringsuppgift som tjänsten kan mappa till ett giltigt Windows-konto.

• Alla CustomBinding som använder en Windows-klientautentiseringsuppgifter med requireCancellation-egenskapen inställd på false.

• Alla CustomBinding som använder ett användarnamn eller en Windows-klients autentiseringsuppgifter och har säker konversation med egenskapen som är inställd på requireCancellationfalse.

I vilken utsträckning tjänsten kan personifiera klienten beror på vilka privilegier tjänstkontot har när det försöker personifiera, vilken typ av personifiering som används och eventuellt omfattningen av personifiering som klienten tillåter.

Identitetsförklädnad i en tjänstemetod: Deklarativ modell

De flesta personifieringsscenarier omfattar körning av tjänstmetoden i anroparens kontext. WCF tillhandahåller en personifieringsfunktion som gör det enkelt att göra det genom att tillåta användaren att ange personifieringskravet OperationBehaviorAttribute i attributet. I följande kodexempel imiterar WCF-infrastrukturen anroparen innan den kör Hello-metoden. Alla försök att komma åt interna resurser i Hello metoden lyckas endast om åtkomstkontrollistan (ACL) för resursen tillåter anroparens åtkomstbehörighet. Om du vill aktivera personifiering anger du Impersonation egenskapen till ett av ImpersonationOption uppräkningsvärdena, antingen ImpersonationOption.Required eller ImpersonationOption.Allowed, enligt följande exempel.

[ServiceContract]
public interface IHelloContract
{
    [OperationContract]
    string Hello(string message);
}

public class HelloService : IHelloService
{
    [OperationBehavior(Impersonation = ImpersonationOption.Required)]
    public string Hello(string message)
    {
        return "hello";
    }
}

<ServiceContract()> _
Public Interface IHelloContract
    <OperationContract()> _
    Function Hello(ByVal message As String) As String
End Interface


Public Class HelloService
    Implements IHelloService

    <OperationBehavior(Impersonation:=ImpersonationOption.Required)> _
    Public Function Hello(ByVal message As String) As String Implements IHelloService.Hello
        Return "hello"
    End Function
End Class

WCF-infrastrukturen kan endast personifiera anroparen om anroparen autentiseras med autentiseringsuppgifter som kan mappas till ett Windows-användarkonto. Om tjänsten är konfigurerad för att autentisera med en autentiseringsuppgift som inte kan mappas till ett Windows-konto körs inte tjänstmetoden.

Maskering i en tjänstmetod: Imperativ modell

Ibland behöver en anropare inte efterlikna hela servicemetoden för korrekt verkställande, utan bara en del av den. I detta fall hämtar du Windows-identiteten för anroparen i tjänstmetoden och utför personifieringen på ett imperativt sätt. Gör detta genom att använda WindowsIdentity egenskapen ServiceSecurityContext för för att returnera en instans av WindowsIdentity klassen och anropa Impersonate metoden innan du använder instansen.

public class HelloService : IHelloService
{
    [OperationBehavior]
    public string Hello(string message)
    {
        WindowsIdentity callerWindowsIdentity =
        ServiceSecurityContext.Current.WindowsIdentity;
        if (callerWindowsIdentity == null)
        {
            throw new InvalidOperationException
           ("The caller cannot be mapped to a WindowsIdentity");
        }
        using (callerWindowsIdentity.Impersonate())
        {
            // Access a file as the caller.
        }
        return "Hello";
    }
}

Public Class HelloService
    Implements IHelloService

    <OperationBehavior()> _
    Public Function Hello(ByVal message As String) As String _
       Implements IHelloService.Hello
        Dim callerWindowsIdentity As WindowsIdentity = _
            ServiceSecurityContext.Current.WindowsIdentity
        If (callerWindowsIdentity Is Nothing) Then
            Throw New InvalidOperationException( _
              "The caller cannot be mapped to a WindowsIdentity")
        End If
        Dim cxt As WindowsImpersonationContext = callerWindowsIdentity.Impersonate()
        Using (cxt)
            ' Access a file as the caller.
        End Using

        Return "Hello"

    End Function
End Class

Personifiering för alla tjänstemetoder

I vissa fall måste du utföra alla metoder för en tjänst i anroparens kontext. I stället för att uttryckligen aktivera den här funktionen per metod använder du ServiceAuthorizationBehavior. Som du ser i följande kod anger du ImpersonateCallerForAllOperations egenskapen till true. ServiceAuthorizationBehavior hämtas från samlingar av beteenden i ServiceHost klassen. Observera också att egenskapen Impersonation för den OperationBehaviorAttribute som tillämpas på varje metod också måste anges till antingen Allowed eller Required.

// Code to create a ServiceHost not shown.
ServiceAuthorizationBehavior MyServiceAuthorizationBehavior =
    serviceHost.Description.Behaviors.Find<ServiceAuthorizationBehavior>();
MyServiceAuthorizationBehavior.ImpersonateCallerForAllOperations = true;

' Code to create a ServiceHost not shown.
Dim MyServiceAuthorizationBehavior As ServiceAuthorizationBehavior
MyServiceAuthorizationBehavior = serviceHost.Description.Behaviors.Find _
(Of ServiceAuthorizationBehavior)()
MyServiceAuthorizationBehavior.ImpersonateCallerForAllOperations = True

I följande tabell beskrivs WCF-beteendet för alla möjliga kombinationer av ImpersonationOption och ImpersonateCallerForAllServiceOperations.

Personifieringsnivå som hämtas från Windows-autentiseringsuppgifter och cachelagrad tokenpersonifiering

I vissa scenarier har klienten partiell kontroll över den personifieringsnivå som tjänsten utför när en Windows-klientautentiseringsuppgift används. Ett scenario inträffar när klienten anger en nivå för anonym personifiering. Det andra inträffar när personifiering utförs med en cachelagrad token. Detta görs genom att ange AllowedImpersonationLevel egenskapen för WindowsClientCredential klassen, som används som en egenskap för den generiska ChannelFactory<TChannel> klassen.

Klienten kan ange personifieringsnivån som Anonymous, Identification, Impersonationeller Delegation. Endast en token på den angivna nivån skapas, enligt följande kod.

ChannelFactory<IEcho> cf = new ChannelFactory<IEcho>("EchoEndpoint");
cf.Credentials.Windows.AllowedImpersonationLevel  =
    System.Security.Principal.TokenImpersonationLevel.Impersonation;

Dim cf As ChannelFactory(Of IEcho) = New ChannelFactory(Of IEcho)("EchoEndpoint")
cf.Credentials.Windows.AllowedImpersonationLevel = _
System.Security.Principal.TokenImpersonationLevel.Impersonation

I följande tabell anges imiteringsnivån som tjänsten uppnår när den imiterar från en cachelagrad token.

Personifieringsnivå som hämtas från autentiseringsuppgifter för användarnamn och cachelagrad tokenpersonifiering

Genom att skicka tjänstens användarnamn och lösenord gör en klient det möjligt för WCF att logga in som den användaren, vilket motsvarar att ställa in AllowedImpersonationLevel egenskapen på Delegation. (Är AllowedImpersonationLevel tillgängligt för klasserna WindowsClientCredential och HttpDigestClientCredential .) Följande tabell innehåller personifieringsnivån som erhålls när tjänsten tar emot autentiseringsuppgifter för användarnamn.

Personifieringsnivå som hämtats från S4U-Based personifiering

Mappa ett klientcertifikat till ett Windows-konto

Det är möjligt för en klient att autentisera sig själv till en tjänst med hjälp av ett certifikat och låta tjänsten mappa klienten till ett befintligt konto via Active Directory. Följande XML visar hur du konfigurerar tjänsten för att mappa certifikatet.

<behaviors>  
  <serviceBehaviors>  
    <behavior name="MapToWindowsAccount">  
      <serviceCredentials>  
        <clientCertificate>  
          <authentication mapClientCertificateToWindowsAccount="true" />  
        </clientCertificate>  
      </serviceCredentials>  
    </behavior>  
  </serviceBehaviors>  
</behaviors>  

Följande kod visar hur du konfigurerar tjänsten.

// Create a binding that sets a certificate as the client credential type.  
WSHttpBinding b = new WSHttpBinding();  
b.Security.Message.ClientCredentialType = MessageCredentialType.Certificate;  
  
// Create a service host that maps the certificate to a Windows account.  
Uri httpUri = new Uri("http://localhost/Calculator");  
ServiceHost sh = new ServiceHost(typeof(HelloService), httpUri);  
sh.Credentials.ClientCertificate.Authentication.MapClientCertificateToWindowsAccount = true;  

Delegering

För att delegera till en bakgrundstjänst måste en tjänst utföra Kerberos multi-leg (SSPI utan NTLM-återgång) eller Kerberos direkta autentisering till bakgrundstjänsten med hjälp av klientens Windows-identitet. Om du vill delegera till en serverdelstjänst skapar du en ChannelFactory<TChannel> och en kanal och kommunicerar sedan via kanalen medan du personifierar klienten. Med den här formen av delegering beror avståndet där serverdelstjänsten kan finnas från klientdelstjänsten på personifieringsnivån som uppnås av klientdelstjänsten. När personifieringsnivån är Impersonationmåste klientdels- och serverdelstjänsterna köras på samma dator. När personifieringsnivån är Delegationkan klientdels- och serverdelstjänsterna finnas på separata datorer eller på samma dator. Aktivering av personifiering på delegeringsnivå kräver att Windows-domänprincipen konfigureras för att tillåta delegering. Mer information om hur du konfigurerar Active Directory för delegeringsstöd finns i Aktivera delegerad autentisering.

Delegeringsförmågan som en funktion på personifieringsnivå

Följande kodexempel visar hur du använder delegering.

public class HelloService : IHelloService
{
    [OperationBehavior(Impersonation = ImpersonationOption.Required)]
    public string Hello(string message)
    {
        WindowsIdentity callerWindowsIdentity = ServiceSecurityContext.Current.WindowsIdentity;
        if (callerWindowsIdentity == null)
        {
            throw new InvalidOperationException
             ("The caller cannot be mapped to a Windows identity.");
        }
        using (callerWindowsIdentity.Impersonate())
        {
            EndpointAddress backendServiceAddress = new EndpointAddress("http://localhost:8000/ChannelApp");
            // Any binding that performs Windows authentication of the client can be used.
            ChannelFactory<IHelloService> channelFactory = new ChannelFactory<IHelloService>(new NetTcpBinding(), backendServiceAddress);
            IHelloService channel = channelFactory.CreateChannel();
            return channel.Hello(message);
        }
    }
}

Public Class HelloService
    Implements IHelloService

    <OperationBehavior(Impersonation:=ImpersonationOption.Required)> _
    Public Function Hello(ByVal message As String) As String Implements IHelloService.Hello
        Dim callerWindowsIdentity As WindowsIdentity = ServiceSecurityContext.Current.WindowsIdentity
        If (callerWindowsIdentity Is Nothing) Then
            Throw New InvalidOperationException("The caller cannot be mapped to a Windows identity.")
        End If

        Dim backendServiceAddress As EndpointAddress = New EndpointAddress("http://localhost:8000/ChannelApp")
        ' Any binding that performs Windows authentication of the client can be used.
        Dim channelFactory As ChannelFactory(Of IHelloService) = _
          New ChannelFactory(Of IHelloService)(New NetTcpBinding(), backendServiceAddress)
        Dim channel As IHelloService = channelFactory.CreateChannel()
        Return channel.Hello(message)
    End Function
End Class

Så här konfigurerar du ett program för att använda begränsad delegering

Innan du kan använda begränsad delegering måste avsändaren, mottagaren och domänkontrollanten konfigureras för att göra det. I följande procedur visas de steg som aktiverar begränsad delegering. Mer information om skillnaderna mellan delegering och begränsad delegering finns i den del av Windows Server 2003 Kerberos-tillägg som diskuterar begränsad diskussion.

1. På domänkontrollanten avmarkerar du kryssrutan Konto är känsligt och kan inte delegeras för det konto som klientprogrammet körs under.

2. På domänkontrollanten markerar du kryssrutan Konto är betrott för delegering för det konto som klientprogrammet körs under.

3. På domänkontrollanten konfigurerar du mellannivådatorn så att den är betrodd för delegering genom att klicka på alternativet Betrodd dator för delegering .

4. På domänkontrollanten konfigurerar du mellannivådatorn så att den använder begränsad delegering genom att klicka på alternativet Lita på den här datorn för delegering till angivna tjänster .

Mer detaljerade anvisningar om hur du konfigurerar begränsad delegering finns i Kerberos-protokollövergång och begränsad delegering.

Se även

• OperationBehaviorAttribute
• Impersonation
• ImpersonationOption
• WindowsIdentity
• ServiceSecurityContext
• WindowsIdentity
• ServiceAuthorizationBehavior
• ImpersonateCallerForAllOperations
• ServiceHost
• AllowedImpersonationLevel
• WindowsClientCredential
• ChannelFactory<TChannel>
• Identification
• Använda identitetsförklädnad med transportskydd
• Utge sig för att vara klienten
• Gör så här: Imitera en klient i en tjänst
• ServiceModel Metadata-verktyg (Svcutil.exe)