Delen via

Procedure: een aangepaste beveiligingstoken authenticator maken

  • Artikel

In dit onderwerp wordt beschreven hoe u een aangepaste beveiligingstoken authenticator maakt en hoe u dit integreert met een aangepast beveiligingstokenbeheer. Een beveiligingstoken authenticator valideert de inhoud van een beveiligingstoken dat wordt geleverd met een binnenkomend bericht. Als de validatie slaagt, retourneert de verificator een verzameling IAuthorizationPolicy exemplaren die, wanneer deze worden geëvalueerd, een set claims retourneert.

Als u een aangepaste beveiligingstoken authenticator in Windows Communication Foundation (WCF) wilt gebruiken, moet u eerst aangepaste referenties en implementaties voor beveiligingstokenbeheer maken. Zie Overzicht: Aangepaste client- en servicereferenties maken voor meer informatie over het maken van aangepaste referenties en een beveiligingstokenbeheer.

Procedures

Een aangepaste beveiligingstoken-verificator maken

  1. Definieer een nieuwe klasse die is afgeleid van de SecurityTokenAuthenticator klasse.

  2. Overschrijf de CanValidateTokenCore methode. De methode retourneert true of afhankelijk van of false de aangepaste verificator het binnenkomende tokentype kan valideren of niet.

  3. Overschrijf de ValidateTokenCore methode. Deze methode moet de inhoud van het token op de juiste wijze valideren. Als het token de validatiestap doorgeeft, wordt er een verzameling IAuthorizationPolicy exemplaren geretourneerd. In het volgende voorbeeld wordt een aangepaste implementatie van het autorisatiebeleid gebruikt die in de volgende procedure wordt gemaakt.

    internal class MySecurityTokenAuthenticator : SecurityTokenAuthenticator
{
    protected override bool CanValidateTokenCore(SecurityToken token)
    {
        // Check that the incoming token is a username token type that
        // can be validated by this implementation.
        return (token is UserNameSecurityToken);
    }

    protected override ReadOnlyCollection<IAuthorizationPolicy>
        ValidateTokenCore(SecurityToken token)
    {
        UserNameSecurityToken userNameToken = token as UserNameSecurityToken;

        // Validate the information contained in the username token. For demonstration
        // purposes, this code just checks that the user name matches the password.
        if (userNameToken.UserName != userNameToken.Password)
        {
            throw new SecurityTokenValidationException("Invalid user name or password");
        }

        // Create just one Claim instance for the username token - the name of the user.
        DefaultClaimSet userNameClaimSet = new DefaultClaimSet(
            ClaimSet.System,
            new Claim(ClaimTypes.Name, userNameToken.UserName, Rights.PossessProperty));
        List<IAuthorizationPolicy> policies = new List<IAuthorizationPolicy>(1);
        policies.Add(new MyAuthorizationPolicy(userNameClaimSet));
        return policies.AsReadOnly();
    }
}

    Friend Class MySecurityTokenAuthenticator
    Inherits SecurityTokenAuthenticator

    Protected Overrides Function CanValidateTokenCore(ByVal token As SecurityToken) As Boolean
        ' Check that the incoming token is a username token type that  
        ' can be validated by this implementation.
        Return (TypeOf token Is UserNameSecurityToken)
    End Function

    Protected Overrides Function ValidateTokenCore(ByVal token As SecurityToken) As ReadOnlyCollection(Of IAuthorizationPolicy)

        Dim userNameToken = TryCast(token, UserNameSecurityToken)

        ' Validate the information contained in the username token. For demonstration 
        ' purposes, this code just checks that the user name matches the password.
        If userNameToken.UserName <> userNameToken.Password Then
            Throw New SecurityTokenValidationException("Invalid user name or password")
        End If

        ' Create just one Claim instance for the username token - the name of the user.
        Dim userNameClaimSet As New DefaultClaimSet(ClaimSet.System, _
                                                    New Claim(ClaimTypes.Name, _
                                                    userNameToken.UserName, _
                                                    Rights.PossessProperty))
        Dim policies As New List(Of IAuthorizationPolicy)(1)
        policies.Add(New MyAuthorizationPolicy(userNameClaimSet))
        Return policies.AsReadOnly()
    End Function

End Class

De vorige code retourneert een verzameling autorisatiebeleidsregels in de CanValidateToken(SecurityToken) methode. WCF biedt geen openbare implementatie van deze interface. In de volgende procedure ziet u hoe u dit doet voor uw eigen vereisten.

Een aangepast autorisatiebeleid maken

  1. Definieer een nieuwe klasse die de IAuthorizationPolicy interface implementeert.

  2. Implementeer de Id eigenschap Alleen-lezen. Een manier om deze eigenschap te implementeren, is door een GUID (Globally Unique Identifier) te genereren in de klasseconstructor en deze telkens te retourneren wanneer de waarde voor deze eigenschap wordt aangevraagd.

  3. Implementeer de Issuer eigenschap Alleen-lezen. Deze eigenschap moet een uitgever retourneren van de claimsets die zijn verkregen van het token. Deze uitgever moet overeenkomen met de uitgever van het token of een instantie die verantwoordelijk is voor het valideren van de inhoud van het token. In het volgende voorbeeld wordt de verlenerclaim gebruikt die aan deze klasse is doorgegeven vanuit de aangepaste beveiligingstoken authenticator die in de vorige procedure is gemaakt. De aangepaste beveiligingstokenverificator maakt gebruik van de door het systeem geleverde claimset (geretourneerd door de System eigenschap) om de verlener van het gebruikersnaamtoken weer te geven.

  4. Implementeer de Evaluate methode. Met deze methode wordt een exemplaar van de EvaluationContext klasse ingevuld (doorgegeven als argument) met claims die zijn gebaseerd op de inhoud van het binnenkomende beveiligingstoken. De methode retourneert true wanneer deze wordt uitgevoerd met de evaluatie. In gevallen waarin de implementatie afhankelijk is van de aanwezigheid van ander autorisatiebeleid dat aanvullende informatie aan de evaluatiecontext biedt, kan deze methode worden geretourneerd false als de vereiste informatie nog niet aanwezig is in de evaluatiecontext. In dat geval roept WCF de methode opnieuw aan nadat alle andere autorisatiebeleidsregels zijn geëvalueerd die zijn gegenereerd voor het binnenkomende bericht als ten minste één van deze autorisatiebeleidsregels de evaluatiecontext heeft gewijzigd.

    internal class MyAuthorizationPolicy : IAuthorizationPolicy
{
    string id;
    ClaimSet tokenClaims;
    ClaimSet issuer;

    public MyAuthorizationPolicy(ClaimSet tokenClaims)
    {
        if (tokenClaims == null)
        {
            throw new ArgumentNullException("tokenClaims");
        }
        this.issuer = tokenClaims.Issuer;
        this.tokenClaims = tokenClaims;
        this.id = Guid.NewGuid().ToString();
    }

    public ClaimSet Issuer
    {
        get { return issuer; }
    }

    public string Id
    {
        get { return id; }
    }

    public bool Evaluate(EvaluationContext evaluationContext, ref object state)
    {
        // Add the token claim set to the evaluation context.
        evaluationContext.AddClaimSet(this, tokenClaims);

        // Return true if the policy evaluation is finished.
        return true;
    }
}

    Friend Class MyAuthorizationPolicy
    Implements IAuthorizationPolicy

    Private _id As String
    Private _tokenClaims As ClaimSet
    Private _issuer As ClaimSet

    Public Sub New(ByVal tokenClaims As ClaimSet)
        If _tokenClaims Is Nothing Then
            Throw New ArgumentNullException("tokenClaims")
        End If
        Me._issuer = tokenClaims.Issuer
        Me._tokenClaims = tokenClaims
        Me._id = Guid.NewGuid().ToString()
    End Sub

    Public ReadOnly Property Issuer() As ClaimSet Implements IAuthorizationPolicy.Issuer
        Get
            Return _issuer
        End Get
    End Property

    Public ReadOnly Property Id() As String Implements System.IdentityModel.Policy.IAuthorizationComponent.Id
        Get
            Return _id
        End Get
    End Property

    Public Function Evaluate(ByVal evaluationContext As EvaluationContext, _
                             ByRef state As Object) As Boolean Implements IAuthorizationPolicy.Evaluate

        ' Add the token claim set to the evaluation context.
        evaluationContext.AddClaimSet(Me, _tokenClaims)
        ' Return true if the policy evaluation is finished.
        Return True
    End Function

End Class

Overzicht: Het maken van aangepaste client- en servicereferenties beschrijft hoe u aangepaste referenties en een aangepast beveiligingstokenbeheer maakt. Als u de aangepaste beveiligingstoken authenticator wilt gebruiken die hier is gemaakt, wordt een implementatie van het beveiligingstokenbeheer gewijzigd om de aangepaste verificator van de CreateSecurityTokenAuthenticator methode te retourneren. De methode retourneert een verificator wanneer een geschikte beveiligingstokenvereiste wordt doorgegeven.

Een aangepaste beveiligingstoken authenticator integreren met een aangepast beveiligingstokenbeheer

  1. Overschrijf de methode in de CreateSecurityTokenAuthenticator implementatie van uw aangepaste beveiligingstokenbeheer.

  2. Voeg logica toe aan de methode om deze in te schakelen voor het retourneren van uw aangepaste beveiligingstoken-verificator op basis van de SecurityTokenRequirement parameter. In het volgende voorbeeld wordt een aangepaste beveiligingstoken-verificator geretourneerd als het tokentype token een gebruikersnaam is (vertegenwoordigd door de UserName eigenschap) en de berichtrichting waarvoor de verificator voor beveiligingstokens wordt aangevraagd, invoer is (vertegenwoordigd door het Input veld).

    internal class MyServiceCredentialsSecurityTokenManager :
    ServiceCredentialsSecurityTokenManager
{
    ServiceCredentials credentials;
    public MyServiceCredentialsSecurityTokenManager(ServiceCredentials credentials)
        : base(credentials)
    {
        this.credentials = credentials;
    }

    public override SecurityTokenAuthenticator CreateSecurityTokenAuthenticator
        (SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver)
    {
        // Return your implementation of the SecurityTokenProvider based on the
        // tokenRequirement argument.
        SecurityTokenAuthenticator result;
        if (tokenRequirement.TokenType == SecurityTokenTypes.UserName)
        {
            MessageDirection direction = tokenRequirement.GetProperty<MessageDirection>
                (ServiceModelSecurityTokenRequirement.MessageDirectionProperty);
            if (direction == MessageDirection.Input)
            {
                outOfBandTokenResolver = null;
                result = new MySecurityTokenAuthenticator();
            }
            else
            {
                result = base.CreateSecurityTokenAuthenticator(tokenRequirement, out outOfBandTokenResolver);
            }
        }
        else
        {
            result = base.CreateSecurityTokenAuthenticator(tokenRequirement, out outOfBandTokenResolver);
        }

        return result;
    }
}

    Friend Class MyServiceCredentialsSecurityTokenManager
    Inherits ServiceCredentialsSecurityTokenManager

    Private credentials As ServiceCredentials

    Public Sub New(ByVal credentials As ServiceCredentials)
        MyBase.New(credentials)
        Me.credentials = credentials
    End Sub

    Public Overrides Function CreateSecurityTokenAuthenticator(ByVal tokenRequirement As SecurityTokenRequirement, _
                                                               <System.Runtime.InteropServices.Out()> _
                                                               ByRef outOfBandTokenResolver _
                                                               As SecurityTokenResolver) As SecurityTokenAuthenticator
        ' Return your implementation of the SecurityTokenProvider based on the 
        ' tokenRequirement argument.
        Dim result As SecurityTokenAuthenticator
        If tokenRequirement.TokenType = SecurityTokenTypes.UserName Then
            Dim direction = tokenRequirement.GetProperty(Of MessageDirection)(ServiceModelSecurityTokenRequirement.MessageDirectionProperty)
            If direction = MessageDirection.Input Then
                outOfBandTokenResolver = Nothing
                result = New MySecurityTokenAuthenticator()
            Else
                result = MyBase.CreateSecurityTokenAuthenticator(tokenRequirement, _
                                                                 outOfBandTokenResolver)
            End If
        Else
            result = MyBase.CreateSecurityTokenAuthenticator(tokenRequirement, _
                                                             outOfBandTokenResolver)
        End If

        Return result
    End Function

End Class

Zie ook