Aracılığıyla paylaş

Nasıl yapılır: Özel Belirteç Oluşturma

  • Makale

Bu konu, sınıfını kullanarak özel bir güvenlik belirtecinin SecurityToken nasıl oluşturulacağını ve bunu özel bir güvenlik belirteci sağlayıcısı ve kimlik doğrulayıcı ile nasıl tümleştirip tümleştiremeyi gösterir. Tam kod örneği için Bkz . Özel Belirteç örneği.

Güvenlik belirteci temelde Windows Communication Foundation (WCF) güvenlik çerçevesi tarafından SOAP iletisinin içindeki bir gönderen hakkındaki talepleri temsil etmek için kullanılan bir XML öğesidir. WCF güvenliği, sistem tarafından sağlanan kimlik doğrulama modları için çeşitli belirteçler sağlar. Örnek olarak sınıfı tarafından X509SecurityToken temsil edilen bir X.509 sertifika güvenlik belirteci veya sınıfı tarafından UserNameSecurityToken temsil edilen kullanıcı adı güvenlik belirteci verilebilir.

Bazen kimlik doğrulama modu veya kimlik bilgisi sağlanan türler tarafından desteklenmez. Bu durumda, SOAP iletisi içindeki özel kimlik bilgilerinin XML gösterimini sağlamak için özel bir güvenlik belirteci oluşturmak gerekir.

Aşağıdaki yordamlarda özel bir güvenlik belirtecinin nasıl oluşturulacağı ve WCF güvenlik altyapısıyla nasıl tümleştirileceği gösterilmektedir. Bu konu, istemcinin kredi kartı hakkındaki bilgileri sunucuya geçirmek için kullanılan bir kredi kartı belirteci oluşturur.

Özel kimlik bilgileri ve güvenlik belirteci yöneticisi hakkında daha fazla bilgi için bkz . İzlenecek Yol: Özel İstemci ve Hizmet Kimlik Bilgileri Oluşturma.

Güvenlik belirteçlerini System.IdentityModel.Tokens temsil eden daha fazla sınıf için ad alanına bakın.

Yordamlar

Bir istemci uygulamasına güvenlik altyapısı için kredi kartı bilgilerini belirtmenin bir yolu sağlanmalıdır. Bu bilgiler, özel istemci kimlik bilgileri sınıfı tarafından uygulamanın kullanımına sunulur. İlk adım, özel istemci kimlik bilgileri için kredi kartı bilgilerini temsil eden bir sınıf oluşturmaktır.

İstemci kimlik bilgileri içinde kredi kartı bilgilerini temsil eden bir sınıf oluşturmak için

  1. Uygulamanın kredi kartı bilgilerini temsil eden yeni bir sınıf tanımlayın. Aşağıdaki örnekte sınıfını CreditCardInfoadlandırabilirsiniz.

  2. Bir uygulamanın özel belirteç için gerekli bilgileri ayarlamasına izin vermek için sınıfına uygun özellikler ekleyin. Bu örnekte, sınıfı üç özelliğe sahiptir: CardNumber, CardIssuerve ExpirationDate.

    public class CreditCardInfo
{
    string cardNumber;
    string cardIssuer;
    DateTime expirationDate;

    public CreditCardInfo(string cardNumber, string cardIssuer, DateTime expirationDate)
    {
        this.cardNumber = cardNumber;
        this.cardIssuer = cardIssuer;
        this.expirationDate = expirationDate;
    }

    public string CardNumber
    {
        get { return this.cardNumber; }
    }

    public string CardIssuer
    {
        get { return this.cardIssuer; }
    }

    public DateTime ExpirationDate
    {
        get { return this.expirationDate; }
    }
}

    Public Class CreditCardInfo

    Private _cardNumber As String
    Private _cardIssuer As String
    Private _expirationDate As DateTime

    Public Sub New(ByVal cardNumber As String, ByVal cardIssuer As String, _
                   ByVal expirationDate As DateTime)
        Me._cardNumber = cardNumber
        Me._cardIssuer = cardIssuer
        Me._expirationDate = expirationDate
    End Sub

    Public ReadOnly Property CardNumber() As String
        Get
            Return Me._cardNumber
        End Get
    End Property

    Public ReadOnly Property CardIssuer() As String
        Get
            Return Me._cardIssuer
        End Get
    End Property

    Public ReadOnly Property ExpirationDate() As DateTime
        Get
            Return Me._expirationDate
        End Get
    End Property

End Class

Ardından, özel güvenlik belirtecini temsil eden bir sınıf oluşturulmalıdır. Bu sınıf güvenlik belirteci sağlayıcısı, kimlik doğrulayıcı ve seri hale getirici sınıfları tarafından WCF güvenlik altyapısına güvenlik belirteci ile ilgili bilgileri geçirmek için kullanılır.

Özel güvenlik belirteci sınıfı oluşturmak için

  1. sınıfından SecurityToken türetilmiş yeni bir sınıf tanımlayın. Bu örnek adlı CreditCardTokenbir sınıf oluşturur.

  2. Id özelliğini geçersiz kılın. Bu özellik, SOAP iletisinin içindeki diğer öğelerden güvenlik belirteci XML gösterimine işaret etmek için kullanılan güvenlik belirtecinin yerel tanımlayıcısını almak için kullanılır. Bu örnekte, bir belirteç tanımlayıcısı buna oluşturucu parametresi olarak geçirilebilir veya her güvenlik belirteci örneği oluşturulduğunda yeni bir rastgele tanımlayıcı oluşturulur.

  3. SecurityKeys özelliğini uygulayın. Bu özellik, güvenlik belirteci örneğinin temsil ettiği bir güvenlik anahtarları koleksiyonu döndürür. Bu tür anahtarlar WCF tarafından SOAP iletisinin bölümlerini imzalamak veya şifrelemek için kullanılabilir. Bu örnekte kredi kartı güvenlik belirteci herhangi bir güvenlik anahtarı içeremez; bu nedenle, uygulama her zaman boş bir koleksiyon döndürür.

  4. ValidFrom ve ValidTo özelliklerini geçersiz kılın. Bu özellikler WCF tarafından güvenlik belirteci örneğinin geçerliliğini belirlemek için kullanılır. Bu örnekte kredi kartı güvenlik belirtecinin yalnızca bir son kullanma tarihi vardır, bu nedenle ValidFrom özellik, örnek oluşturma tarihini ve saatini temsil eden bir DateTime döndürür.

    class CreditCardToken : SecurityToken
{
    CreditCardInfo cardInfo;
    DateTime effectiveTime = DateTime.UtcNow;
    string id;
    ReadOnlyCollection<SecurityKey> securityKeys;

    public CreditCardToken(CreditCardInfo cardInfo) : this(cardInfo, Guid.NewGuid().ToString()) { }

    public CreditCardToken(CreditCardInfo cardInfo, string id)
    {
        if (cardInfo == null)
        {
            throw new ArgumentNullException("cardInfo");
        }
        if (id == null)
        {
            throw new ArgumentNullException("id");
        }

        this.cardInfo = cardInfo;
        this.id = id;
        // The credit card token is not capable of any cryptography.
        this.securityKeys = new ReadOnlyCollection<SecurityKey>(new List<SecurityKey>());
    }

    public CreditCardInfo CardInfo
    {
        get { return this.cardInfo; }
    }

    public override ReadOnlyCollection<SecurityKey> SecurityKeys
    {
        get { return this.securityKeys; }
    }

    public override DateTime ValidFrom
    {
        get { return this.effectiveTime; }
    }

    public override DateTime ValidTo
    {
        get { return this.cardInfo.ExpirationDate; }
    }

    public override string Id
    {
        get { return this.id; }
    }
}

    Friend Class CreditCardToken
    Inherits SecurityToken

    Private _cardInfo As CreditCardInfo
    Private _effectiveTime As DateTime = DateTime.UtcNow
    Private _id As String
    Private _securityKeys As ReadOnlyCollection(Of SecurityKey)

    Public Sub New(ByVal cardInfo As CreditCardInfo)
        Me.New(cardInfo, Guid.NewGuid().ToString())
    End Sub

    Public Sub New(ByVal cardInfo As CreditCardInfo, _
                   ByVal id As String)
        If cardInfo Is Nothing Then
            Throw New ArgumentNullException("cardInfo")
        End If
        If id Is Nothing Then
            Throw New ArgumentNullException("id")
        End If

        Me._cardInfo = cardInfo
        Me._id = id
        ' The credit card token is not capable of any cryptography.
        Me._securityKeys = New ReadOnlyCollection(Of SecurityKey)(New List(Of SecurityKey)())
    End Sub

    Public ReadOnly Property CardInfo() As CreditCardInfo
        Get
            Return Me._cardInfo
        End Get
    End Property

    Public Overrides ReadOnly Property SecurityKeys() As ReadOnlyCollection(Of SecurityKey)
        Get
            Return Me._securityKeys
        End Get
    End Property

    Public Overrides ReadOnly Property ValidFrom() As DateTime
        Get
            Return Me._effectiveTime
        End Get
    End Property

    Public Overrides ReadOnly Property ValidTo() As DateTime
        Get
            Return Me._cardInfo.ExpirationDate
        End Get
    End Property

    Public Overrides ReadOnly Property Id() As String
        Get
            Return Me._id
        End Get
    End Property
End Class

Yeni bir güvenlik belirteci türü oluşturulduğunda, sınıfının bir uygulamasını SecurityTokenParameters gerektirir. Uygulama, yeni belirteç türünü temsil etmek için güvenlik bağlama öğesi yapılandırmasında kullanılır. Güvenlik belirteci parametreleri sınıfı, bir ileti işlendiğinde gerçek güvenlik belirteci örneğini eşleştirmek için kullanılan bir şablon görevi görür. Şablon, bir uygulamanın güvenlik belirtecinin kullanılması veya kimliği doğrulanması için eşleşmesi gereken ölçütleri belirtmek için kullanabileceği ek özellikler sağlar. Aşağıdaki örnek ek özellik eklemediğinden, WCF altyapısı kullanılacak veya doğrulanması gereken bir güvenlik belirteci örneğini ararken yalnızca güvenlik belirteci türü eşleştirilir.

Özel güvenlik belirteci parametreleri sınıfı oluşturmak için

  1. sınıfından SecurityTokenParameters türetilmiş yeni bir sınıf tanımlayın.

  2. CloneCore yöntemini uygulayın. Varsa sınıfınızda tanımlanan tüm iç alanları kopyalayın. Bu örnek ek alan tanımlamaz.

  3. SupportsClientAuthentication Salt okunur özelliğini uygulayın. Bu özellik, bu sınıf tarafından temsil edilen güvenlik belirteci türünün bir hizmette istemcinin kimliğini doğrulamak için kullanılıp kullanılamayabileceğini döndürür true . Bu örnekte, kredi kartı güvenlik belirteci bir hizmette istemcinin kimliğini doğrulamak için kullanılabilir.

  4. SupportsServerAuthentication Salt okunur özelliğini uygulayın. Bu özellik, bu sınıf tarafından temsil edilen güvenlik belirteci türünün istemcide bir hizmetin kimliğini doğrulamak için kullanılıp kullanılamayabileceğini döndürür true . Bu örnekte, kredi kartı güvenlik belirteci bir hizmetin istemcisinde kimliğini doğrulamak için kullanılamaz.

  5. SupportsClientWindowsIdentity Salt okunur özelliğini uygulayın. Bu özellik, bu sınıf tarafından temsil edilen güvenlik belirteci türünün bir Windows hesabıyla eşlenebildiğini döndürür true . Bu durumda, kimlik doğrulama sonucu bir WindowsIdentity sınıf örneği tarafından temsil edilir. Bu örnekte belirteç bir Windows hesabına eşlenemez.

  6. CreateKeyIdentifierClause(SecurityToken, SecurityTokenReferenceStyle) yöntemini uygulayın. Bu yöntem, bu güvenlik belirteci parametre sınıfı tarafından temsil edilen güvenlik belirteci örneğine başvuru gerektirdiğinde WCF güvenlik çerçevesi tarafından çağrılır. Hem gerçek güvenlik belirteci örneği hem SecurityTokenReferenceStyle de istenen başvurunun türünü belirten bu yönteme bağımsız değişken olarak geçirilir. Bu örnekte, kredi kartı güvenlik belirteci tarafından yalnızca iç başvurular desteklenir. sınıfı iç SecurityToken başvurular oluşturma işlevselliğine sahiptir; bu nedenle uygulama ek kod gerektirmez.

  7. InitializeSecurityTokenRequirement(SecurityTokenRequirement) yöntemini uygulayın. Bu yöntem, güvenlik belirteci parametreleri sınıf örneğini sınıfının bir örneğine dönüştürmek için WCF tarafından çağrılır SecurityTokenRequirement . Sonuç, güvenlik belirteci sağlayıcıları tarafından uygun güvenlik belirteci örneğini oluşturmak için kullanılır.

    public class CreditCardTokenParameters : SecurityTokenParameters
{
    public CreditCardTokenParameters()
    {
    }

    protected CreditCardTokenParameters(CreditCardTokenParameters other)
        : base(other)
    {
    }

    protected override SecurityTokenParameters CloneCore()
    {
        return new CreditCardTokenParameters(this);
    }

    protected override void InitializeSecurityTokenRequirement(SecurityTokenRequirement requirement)
    {
        requirement.TokenType = Constants.CreditCardTokenType;
        return;
    }

    // A credit card token has no cryptography, no windows identity, and supports only client authentication.
    protected override bool HasAsymmetricKey
    {
        get { return false; }
    }

    protected override bool SupportsClientAuthentication
    {
        get { return true; }
    }

    protected override bool SupportsClientWindowsIdentity
    {
        get { return false; }
    }

    protected override bool SupportsServerAuthentication
    {
        get { return false; }
    }

    protected override SecurityKeyIdentifierClause CreateKeyIdentifierClause(SecurityToken token, SecurityTokenReferenceStyle referenceStyle)
    {
        if (referenceStyle == SecurityTokenReferenceStyle.Internal)
        {
            return token.CreateKeyIdentifierClause<LocalIdKeyIdentifierClause>();
        }
        else
        {
            throw new NotSupportedException("External references are not supported for credit card tokens");
        }
    }
}

    Public Class CreditCardTokenParameters
    Inherits SecurityTokenParameters

    Public Sub New()
    End Sub

    Protected Sub New(ByVal other As CreditCardTokenParameters)
        MyBase.New(other)
    End Sub

    Protected Overrides Function CloneCore() As SecurityTokenParameters
        Return New CreditCardTokenParameters(Me)
    End Function

    Protected Overrides Sub InitializeSecurityTokenRequirement(ByVal requirement As SecurityTokenRequirement)
        requirement.TokenType = Constants.CreditCardTokenType
        Return
    End Sub

    ' A credit card token has no cryptography, no windows identity, and supports only client authentication.
    Protected Overrides ReadOnly Property HasAsymmetricKey() As Boolean
        Get
            Return False
        End Get
    End Property

    Protected Overrides ReadOnly Property SupportsClientAuthentication() As Boolean
        Get
            Return True
        End Get
    End Property

    Protected Overrides ReadOnly Property SupportsClientWindowsIdentity() As Boolean
        Get
            Return False
        End Get
    End Property

    Protected Overrides ReadOnly Property SupportsServerAuthentication() As Boolean
        Get
            Return False
        End Get
    End Property

    Protected Overrides Function CreateKeyIdentifierClause(ByVal token As SecurityToken, _
                                                           ByVal referenceStyle As SecurityTokenReferenceStyle) As SecurityKeyIdentifierClause
        If referenceStyle = SecurityTokenReferenceStyle.Internal Then
            Return token.CreateKeyIdentifierClause(Of LocalIdKeyIdentifierClause)()
        Else
            Throw New NotSupportedException("External references are not supported for credit card tokens")
        End If
    End Function

End Class

Güvenlik belirteçleri SOAP iletileri içinde iletilir ve bu, bellek içi güvenlik belirteci gösterimi ile kablolu gösterim arasında bir çeviri mekanizması gerektirir. WCF, bu görevi gerçekleştirmek için bir güvenlik belirteci serileştiricisi kullanır. Her özel belirtecin, SOAP iletisinden özel güvenlik belirtecini seri hale getirebilen ve seri durumdan çıkarabilen özel bir güvenlik belirteci seri hale getiricisi eşlik etmelidir.

Not

Türetilmiş anahtarlar varsayılan olarak etkindir. Özel bir güvenlik belirteci oluşturur ve bunu birincil belirteç olarak kullanırsanız, WCF ondan bir anahtar türetir. Bunu yaparken, özel güvenlik belirteci için yazmak SecurityKeyIdentifierClause için özel güvenlik belirteci seri hale getiricisini çağırır ve kabloya seri hale getirilir DerivedKeyToken . Alıcı uçta, belirteci kablodan seri durumdan çıkarırken seri hale getirici bir DerivedKeyToken öğeyi kendi altında en üst düzey alt öğe olarak bekler SecurityTokenReference . Özel güvenlik belirteci seri hale getirici yan tümce türü seri hale getirilirken bir SecurityTokenReference öğe eklemediyse, bir özel durum oluşturulur.

Özel güvenlik belirteci seri hale getiricisi oluşturmak için

  1. sınıfından WSSecurityTokenSerializer türetilmiş yeni bir sınıf tanımlayın.

  2. CanReadTokenCore(XmlReader) XML akışını okumak için bir XmlReader bağımlı olan yöntemini geçersiz kılın. yöntemi, seri hale getirici uygulaması geçerli öğesine göre güvenlik belirtecini seri durumdan çıkarabiliyorsa döndürür true . Bu örnekte, bu yöntem XML okuyucusunun geçerli XML öğesinin doğru öğe adına ve ad alanına sahip olup olmadığını denetler. Aksi takdirde, XML öğesini işlemek için bu yöntemin temel sınıf uygulamasını çağırır.

  3. ReadTokenCore(XmlReader, SecurityTokenResolver) yöntemini geçersiz kılın. Bu yöntem, güvenlik belirtecinin XML içeriğini okur ve bunun için uygun bellek içi gösterimi oluşturur. Geçirilen XML okuyucunun üzerinde durduğu XML öğesini tanımıyorsa, sistem tarafından sağlanan belirteç türlerini işlemek için temel sınıf uygulamasını çağırır.

  4. CanWriteTokenCore(SecurityToken) yöntemini geçersiz kılın. Bu yöntem, bellek içi belirteç gösterimini (bağımsız değişken olarak geçirilir) XML gösterimine dönüştürebiliyorsa döndürür true . Dönüştüremezse, temel sınıf uygulamasını çağırır.

  5. WriteTokenCore(XmlWriter, SecurityToken) yöntemini geçersiz kılın. Bu yöntem, bellek içi güvenlik belirteci gösterimini XML gösterimine dönüştürür. yöntemi dönüştüremezse, temel sınıf uygulamasını çağırır.

    public class CreditCardSecurityTokenSerializer : WSSecurityTokenSerializer
{
    public CreditCardSecurityTokenSerializer(SecurityTokenVersion version) : base() { }

    protected override bool CanReadTokenCore(XmlReader reader)
    {
        XmlDictionaryReader localReader = XmlDictionaryReader.CreateDictionaryReader(reader);
        if (reader == null)
        {
            throw new ArgumentNullException("reader");
        }
        if (reader.IsStartElement(Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace))
        {
            return true;
        }
        return base.CanReadTokenCore(reader);
    }

    protected override SecurityToken ReadTokenCore(XmlReader reader, SecurityTokenResolver tokenResolver)
    {
        if (reader == null)
        {
            throw new ArgumentNullException("reader");
        }
        if (reader.IsStartElement(Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace))
        {
            string id = reader.GetAttribute(Constants.Id, Constants.WsUtilityNamespace);

            reader.ReadStartElement();

            // Read the credit card number.
            string creditCardNumber = reader.ReadElementString(Constants.CreditCardNumberElementName, Constants.CreditCardTokenNamespace);

            // Read the expiration date.
            string expirationTimeString = reader.ReadElementString(Constants.CreditCardExpirationElementName, Constants.CreditCardTokenNamespace);
            DateTime expirationTime = XmlConvert.ToDateTime(expirationTimeString, XmlDateTimeSerializationMode.Utc);

            // Read the issuer of the credit card.
            string creditCardIssuer = reader.ReadElementString(Constants.CreditCardIssuerElementName, Constants.CreditCardTokenNamespace);
            reader.ReadEndElement();

            CreditCardInfo cardInfo = new CreditCardInfo(creditCardNumber, creditCardIssuer, expirationTime);

            return new CreditCardToken(cardInfo, id);
        }
        else
        {
            return WSSecurityTokenSerializer.DefaultInstance.ReadToken(reader, tokenResolver);
        }
    }

    protected override bool CanWriteTokenCore(SecurityToken token)
    {
        if (token is CreditCardToken)
        {
            return true;
        }
        else
        {
            return base.CanWriteTokenCore(token);
        }
    }

    protected override void WriteTokenCore(XmlWriter writer, SecurityToken token)
    {
        if (writer == null)
        {
            throw new ArgumentNullException("writer");
        }
        if (token == null)
        {
            throw new ArgumentNullException("token");
        }

        CreditCardToken c = token as CreditCardToken;
        if (c != null)
        {
            writer.WriteStartElement(Constants.CreditCardTokenPrefix, Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace);
            writer.WriteAttributeString(Constants.WsUtilityPrefix, Constants.Id, Constants.WsUtilityNamespace, token.Id);
            writer.WriteElementString(Constants.CreditCardNumberElementName, Constants.CreditCardTokenNamespace, c.CardInfo.CardNumber);
            writer.WriteElementString(Constants.CreditCardExpirationElementName, Constants.CreditCardTokenNamespace, XmlConvert.ToString(c.CardInfo.ExpirationDate, XmlDateTimeSerializationMode.Utc));
            writer.WriteElementString(Constants.CreditCardIssuerElementName, Constants.CreditCardTokenNamespace, c.CardInfo.CardIssuer);
            writer.WriteEndElement();
            writer.Flush();
        }
        else
        {
            base.WriteTokenCore(writer, token);
        }
    }
}

    Public Class CreditCardSecurityTokenSerializer
    Inherits WSSecurityTokenSerializer

    Public Sub New(ByVal version As SecurityTokenVersion)
        MyBase.New()
    End Sub

    Protected Overrides Function CanReadTokenCore(ByVal reader As XmlReader) As Boolean
        Dim localReader = XmlDictionaryReader.CreateDictionaryReader(reader)
        If reader Is Nothing Then
            Throw New ArgumentNullException("reader")
        End If
        If reader.IsStartElement(Constants.CreditCardTokenName, _
                                 Constants.CreditCardTokenNamespace) Then
            Return True
        End If
        Return MyBase.CanReadTokenCore(reader)
    End Function

    Protected Overrides Function ReadTokenCore(ByVal reader As XmlReader, _
                                               ByVal tokenResolver As SecurityTokenResolver) As SecurityToken
        If reader Is Nothing Then
            Throw New ArgumentNullException("reader")
        End If
        If reader.IsStartElement(Constants.CreditCardTokenName, _
                                 Constants.CreditCardTokenNamespace) Then

            Dim id = reader.GetAttribute(Constants.Id, _
                                         Constants.WsUtilityNamespace)
            reader.ReadStartElement()

            ' Read the credit card number.
            Dim creditCardNumber = reader.ReadElementString(Constants.CreditCardNumberElementName, _
                                                            Constants.CreditCardTokenNamespace)

            ' Read the expiration date.
            Dim expirationTimeString = reader.ReadElementString(Constants.CreditCardExpirationElementName, _
                                                                Constants.CreditCardTokenNamespace)
            Dim expirationTime As DateTime = XmlConvert.ToDateTime(expirationTimeString, _
                                                                   XmlDateTimeSerializationMode.Utc)

            ' Read the issuer of the credit card.
            Dim creditCardIssuer = reader.ReadElementString(Constants.CreditCardIssuerElementName, _
                                                            Constants.CreditCardTokenNamespace)
            reader.ReadEndElement()

            Dim cardInfo As New CreditCardInfo(creditCardNumber, _
                                               creditCardIssuer, _
                                               expirationTime)

            Return New CreditCardToken(cardInfo, id)
        Else
            Return WSSecurityTokenSerializer.DefaultInstance.ReadToken(reader, _
                                                                       tokenResolver)
        End If
    End Function

    Protected Overrides Function CanWriteTokenCore(ByVal token As SecurityToken) As Boolean
        If TypeOf token Is CreditCardToken Then
            Return True
        Else
            Return MyBase.CanWriteTokenCore(token)
        End If
    End Function

    Protected Overrides Sub WriteTokenCore(ByVal writer As XmlWriter, _
                                           ByVal token As SecurityToken)
        If writer Is Nothing Then
            Throw New ArgumentNullException("writer")
        End If
        If token Is Nothing Then
            Throw New ArgumentNullException("token")
        End If

        Dim c = TryCast(token, CreditCardToken)
        If c IsNot Nothing Then
            With writer
                .WriteStartElement(Constants.CreditCardTokenPrefix, _
                                   Constants.CreditCardTokenName, _
                                   Constants.CreditCardTokenNamespace)
                .WriteAttributeString(Constants.WsUtilityPrefix, _
                                      Constants.Id, _
                                      Constants.WsUtilityNamespace, _
                                      token.Id)
                .WriteElementString(Constants.CreditCardNumberElementName, _
                                    Constants.CreditCardTokenNamespace, _
                                    c.CardInfo.CardNumber)
                .WriteElementString(Constants.CreditCardExpirationElementName, _
                                    Constants.CreditCardTokenNamespace, _
                                    XmlConvert.ToString(c.CardInfo.ExpirationDate, _
                                                        XmlDateTimeSerializationMode.Utc))
                .WriteElementString(Constants.CreditCardIssuerElementName, _
                                    Constants.CreditCardTokenNamespace, _
                                    c.CardInfo.CardIssuer)
                .WriteEndElement()
                .Flush()
            End With
        Else
            MyBase.WriteTokenCore(writer, token)
        End If
    End Sub

End Class

Önceki dört yordamı tamamladıktan sonra özel güvenlik belirtecini güvenlik belirteci sağlayıcısı, kimlik doğrulayıcı, yönetici ve istemci ve hizmet kimlik bilgileriyle tümleştirin.

Özel güvenlik belirtecini bir güvenlik belirteci sağlayıcısıyla tümleştirmek için

  1. Güvenlik belirteci sağlayıcısı belirteç oluşturur, değiştirir (gerekirse) ve belirtecin bir örneğini döndürür. Özel güvenlik belirteci için özel bir sağlayıcı oluşturmak için sınıfından SecurityTokenProvider devralan bir sınıf oluşturun. Aşağıdaki örnek, öğesinin GetTokenCore bir örneğini CreditCardTokendöndürmek için yöntemini geçersiz kılar. Özel güvenlik belirteci sağlayıcıları hakkında daha fazla bilgi için bkz . Nasıl yapılır: Özel Güvenlik Belirteci Sağlayıcısı Oluşturma.

    class CreditCardTokenProvider : SecurityTokenProvider
{
    CreditCardInfo creditCardInfo;

    public CreditCardTokenProvider(CreditCardInfo creditCardInfo)
        : base()
    {
        if (creditCardInfo == null)
        {
            throw new ArgumentNullException("creditCardInfo");
        }
        this.creditCardInfo = creditCardInfo;
    }

    protected override SecurityToken GetTokenCore(TimeSpan timeout)
    {
        SecurityToken result = new CreditCardToken(this.creditCardInfo);
        return result;
    }
}

    Friend Class CreditCardTokenProvider
    Inherits SecurityTokenProvider

    Private creditCardInfo As CreditCardInfo

    Public Sub New(ByVal creditCardInfo As CreditCardInfo)
        MyBase.New()
        If creditCardInfo Is Nothing Then
            Throw New ArgumentNullException("creditCardInfo")
        End If
        Me.creditCardInfo = creditCardInfo
    End Sub

    Protected Overrides Function GetTokenCore(ByVal timeout As TimeSpan) As SecurityToken
        Return TryCast(New CreditCardToken(Me.creditCardInfo), SecurityToken)
    End Function

End Class

Özel güvenlik belirtecini bir güvenlik belirteci kimlik doğrulayıcısıyla tümleştirmek için

  1. Güvenlik belirteci doğrulayıcı, iletiden ayıklandığında güvenlik belirtecinin içeriğini doğrular. Özel güvenlik belirteci için özel bir kimlik doğrulayıcı oluşturmak için sınıfından SecurityTokenAuthenticator devralan bir sınıf oluşturun. Aşağıdaki örnek yöntemini geçersiz kılar ValidateTokenCore . Özel güvenlik belirteci doğrulayıcıları hakkında daha fazla bilgi için bkz . Nasıl yapılır: Özel Güvenlik Belirteci Doğrulayıcı Oluşturma.

    class CreditCardTokenAuthenticator : SecurityTokenAuthenticator
{
    string creditCardsFile;
    public CreditCardTokenAuthenticator(string creditCardsFile)
    {
        this.creditCardsFile = creditCardsFile;
    }

    protected override bool CanValidateTokenCore(SecurityToken token)
    {
        return (token is CreditCardToken);
    }

    protected override ReadOnlyCollection<IAuthorizationPolicy> ValidateTokenCore(SecurityToken token)
    {
        CreditCardToken creditCardToken = token as CreditCardToken;

        if (creditCardToken.CardInfo.ExpirationDate < DateTime.UtcNow)
        {
            throw new SecurityTokenValidationException("The credit card has expired");
        }
        if (!IsCardNumberAndExpirationValid(creditCardToken.CardInfo))
        {
            throw new SecurityTokenValidationException("Unknown or invalid credit card");
        }

        // The credit card token has only 1 claim: the card number. The issuer for the claim is the
        // credit card issuer.
        DefaultClaimSet cardIssuerClaimSet = new DefaultClaimSet(new Claim(ClaimTypes.Name, creditCardToken.CardInfo.CardIssuer, Rights.PossessProperty));
        DefaultClaimSet cardClaimSet = new DefaultClaimSet(cardIssuerClaimSet, new Claim(Constants.CreditCardNumberClaim, creditCardToken.CardInfo.CardNumber, Rights.PossessProperty));
        List<IAuthorizationPolicy> policies = new List<IAuthorizationPolicy>(1);
        policies.Add(new CreditCardTokenAuthorizationPolicy(cardClaimSet));
        return policies.AsReadOnly();
    }

    // This helper method checks whether a given credit card entry is present in the user database.
    private bool IsCardNumberAndExpirationValid(CreditCardInfo cardInfo)
    {
        try
        {
            using (StreamReader myStreamReader = new StreamReader(this.creditCardsFile))
            {
                string line = "";
                while ((line = myStreamReader.ReadLine()) != null)
                {
                    string[] splitEntry = line.Split('#');
                    if (splitEntry[0] == cardInfo.CardNumber)
                    {
                        string expirationDateString = splitEntry[1].Trim();
                        DateTime expirationDateOnFile = DateTime.Parse(expirationDateString, System.Globalization.DateTimeFormatInfo.InvariantInfo, System.Globalization.DateTimeStyles.AdjustToUniversal);
                        if (cardInfo.ExpirationDate == expirationDateOnFile)
                        {
                            string issuer = splitEntry[2];
                            return issuer.Equals(cardInfo.CardIssuer, StringComparison.InvariantCultureIgnoreCase);
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                return false;
            }
        }
        catch (Exception e)
        {
            throw new Exception("BookStoreService: Error while retrieving credit card information from User DB " + e.ToString());
        }
    }
}

    Friend Class CreditCardTokenAuthenticator
    Inherits SecurityTokenAuthenticator

    Private creditCardsFile As String

    Public Sub New(ByVal creditCardsFile As String)
        Me.creditCardsFile = creditCardsFile
    End Sub

    Protected Overrides Function CanValidateTokenCore(ByVal token As SecurityToken) As Boolean
        Return (TypeOf token Is CreditCardToken)
    End Function

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

        Dim creditCardToken = TryCast(token, CreditCardToken)

        If creditCardToken.CardInfo.ExpirationDate < DateTime.UtcNow Then
            Throw New SecurityTokenValidationException("The credit card has expired")
        End If
        If Not IsCardNumberAndExpirationValid(creditCardToken.CardInfo) Then
            Throw New SecurityTokenValidationException("Unknown or invalid credit card")
        End If

        ' The credit card token has only 1 claim: the card number. The issuer for the claim is the
        ' credit card issuer.
        Dim cardIssuerClaimSet As New DefaultClaimSet(New Claim(ClaimTypes.Name, _
                                                                creditCardToken.CardInfo.CardIssuer, _
                                                                Rights.PossessProperty))
        Dim cardClaimSet As New DefaultClaimSet(cardIssuerClaimSet, _
                                                New Claim(Constants.CreditCardNumberClaim, _
                                                          creditCardToken.CardInfo.CardNumber, _
                                                          Rights.PossessProperty))
        Dim policies As New List(Of IAuthorizationPolicy)(1)
        policies.Add(New CreditCardTokenAuthorizationPolicy(cardClaimSet))
        Return policies.AsReadOnly()
    End Function

    ' This helper method checks whether a given credit card entry is present in the user database.
    Private Function IsCardNumberAndExpirationValid(ByVal cardInfo As CreditCardInfo) As Boolean
        Try
            Using myStreamReader As New StreamReader(Me.creditCardsFile)
                Dim line = String.Empty
                line = myStreamReader.ReadLine()
                Do While line IsNot Nothing
                    Dim splitEntry() = line.Split("#"c)
                    If splitEntry(0) = cardInfo.CardNumber Then
                        Dim expirationDateString = splitEntry(1).Trim()
                        Dim expirationDateOnFile As DateTime = DateTime.Parse(expirationDateString, _
                                                                              System.Globalization.DateTimeFormatInfo.InvariantInfo, _
                                                                              System.Globalization.DateTimeStyles.AdjustToUniversal)
                        If cardInfo.ExpirationDate = expirationDateOnFile Then
                            Dim issuer = splitEntry(2)
                            Return issuer.Equals(cardInfo.CardIssuer, _
                                                 StringComparison.InvariantCultureIgnoreCase)
                        Else
                            Return False
                        End If
                    End If
                    line = myStreamReader.ReadLine()
                Loop
                Return False
            End Using
        Catch e As Exception
            Throw New Exception("BookStoreService: Error while retrieving credit card information from User DB " & e.ToString())
        End Try
    End Function

End Class

    public class CreditCardTokenAuthorizationPolicy : IAuthorizationPolicy
{
    string id;
    ClaimSet issuer;
    IEnumerable<ClaimSet> issuedClaimSets;

    public CreditCardTokenAuthorizationPolicy(ClaimSet issuedClaims)
    {
        if (issuedClaims == null)
            throw new ArgumentNullException("issuedClaims");
        this.issuer = issuedClaims.Issuer;
        this.issuedClaimSets = new ClaimSet[] { issuedClaims };
        this.id = Guid.NewGuid().ToString();
    }

    public ClaimSet Issuer { get { return this.issuer; } }

    public string Id { get { return this.id; } }

    public bool Evaluate(EvaluationContext context, ref object state)
    {
        foreach (ClaimSet issuance in this.issuedClaimSets)
        {
            context.AddClaimSet(this, issuance);
        }

        return true;
    }
}

    Public Class CreditCardTokenAuthorizationPolicy
    Implements IAuthorizationPolicy

    Private _id As String
    Private _issuer As ClaimSet
    Private _issuedClaimSets As IEnumerable(Of ClaimSet)

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

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

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

    Public Function Evaluate(ByVal context As EvaluationContext, _
                             ByRef state As Object) As Boolean Implements IAuthorizationPolicy.Evaluate
        For Each issuance In Me._issuedClaimSets
            context.AddClaimSet(Me, issuance)
        Next issuance

        Return True
    End Function

End Class

Özel güvenlik belirtecini bir güvenlik belirteci yöneticisiyle tümleştirmek için

  1. Güvenlik belirteci yöneticisi uygun belirteç sağlayıcısını, güvenlik kimlik doğrulayıcısını ve belirteç seri hale getirici örneklerini oluşturur. Özel belirteç yöneticisi oluşturmak için sınıfından ClientCredentialsSecurityTokenManager devralan bir sınıf oluşturun. sınıfının birincil yöntemleri, uygun sağlayıcıyı ve istemci veya hizmet kimlik bilgilerini oluşturmak için kullanır SecurityTokenRequirement . Özel güvenlik belirteci yöneticileri hakkında daha fazla bilgi için bkz . İzlenecek Yol: Özel İstemci ve Hizmet Kimlik Bilgileri Oluşturma.

    public class CreditCardClientCredentialsSecurityTokenManager : ClientCredentialsSecurityTokenManager
{
    CreditCardClientCredentials creditCardClientCredentials;

    public CreditCardClientCredentialsSecurityTokenManager(CreditCardClientCredentials creditCardClientCredentials)
        : base(creditCardClientCredentials)
    {
        this.creditCardClientCredentials = creditCardClientCredentials;
    }

    public override SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement)
    {
        if (tokenRequirement.TokenType == Constants.CreditCardTokenType)
        {
            // Handle this token for Custom.
            return new CreditCardTokenProvider(this.creditCardClientCredentials.CreditCardInfo);
        }
        else if (tokenRequirement is InitiatorServiceModelSecurityTokenRequirement)
        {
            // Return server certificate.
            if (tokenRequirement.TokenType == SecurityTokenTypes.X509Certificate)
            {
                return new X509SecurityTokenProvider(creditCardClientCredentials.ServiceCertificate.DefaultCertificate);
            }
        }
        return base.CreateSecurityTokenProvider(tokenRequirement);
    }

    public override SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version)
    {
        return new CreditCardSecurityTokenSerializer(version);
    }
}

    Public Class CreditCardClientCredentialsSecurityTokenManager
    Inherits ClientCredentialsSecurityTokenManager

    Private creditCardClientCredentials As CreditCardClientCredentials

    Public Sub New(ByVal creditCardClientCredentials As CreditCardClientCredentials)
        MyBase.New(creditCardClientCredentials)
        Me.creditCardClientCredentials = creditCardClientCredentials
    End Sub

    Public Overrides Function CreateSecurityTokenProvider(ByVal tokenRequirement As SecurityTokenRequirement) As SecurityTokenProvider

        If tokenRequirement.TokenType = Constants.CreditCardTokenType Then
            ' Handle this token for Custom.
            Return New CreditCardTokenProvider(Me.creditCardClientCredentials.CreditCardInfo)
        ElseIf TypeOf tokenRequirement Is InitiatorServiceModelSecurityTokenRequirement Then
            ' Return server certificate.
            If tokenRequirement.TokenType = SecurityTokenTypes.X509Certificate Then
                Return New X509SecurityTokenProvider(creditCardClientCredentials.ServiceCertificate.DefaultCertificate)
            End If
        End If
        Return MyBase.CreateSecurityTokenProvider(tokenRequirement)
    End Function

    Public Overloads Overrides Function CreateSecurityTokenSerializer(ByVal version As SecurityTokenVersion) As SecurityTokenSerializer
        Return New CreditCardSecurityTokenSerializer(version)
    End Function

End Class

    public class CreditCardServiceCredentialsSecurityTokenManager : ServiceCredentialsSecurityTokenManager
{
    CreditCardServiceCredentials creditCardServiceCredentials;

    public CreditCardServiceCredentialsSecurityTokenManager(CreditCardServiceCredentials creditCardServiceCredentials)
        : base(creditCardServiceCredentials)
    {
        this.creditCardServiceCredentials = creditCardServiceCredentials;
    }

    public override SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver)
    {
        if (tokenRequirement.TokenType == Constants.CreditCardTokenType)
        {
            outOfBandTokenResolver = null;
            return new CreditCardTokenAuthenticator(creditCardServiceCredentials.CreditCardDataFile);
        }
        return base.CreateSecurityTokenAuthenticator(tokenRequirement, out outOfBandTokenResolver);
    }

    public override SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version)
    {
        return new CreditCardSecurityTokenSerializer(version);
    }
}

    Public Class CreditCardServiceCredentialsSecurityTokenManager
    Inherits ServiceCredentialsSecurityTokenManager

    Private creditCardServiceCredentials As CreditCardServiceCredentials

    Public Sub New(ByVal creditCardServiceCredentials As CreditCardServiceCredentials)
        MyBase.New(creditCardServiceCredentials)
        Me.creditCardServiceCredentials = creditCardServiceCredentials
    End Sub

    Public Overrides Function CreateSecurityTokenAuthenticator(ByVal tokenRequirement As SecurityTokenRequirement, _
                                                               <System.Runtime.InteropServices.Out()> ByRef outOfBandTokenResolver As SecurityTokenResolver) As SecurityTokenAuthenticator
        If tokenRequirement.TokenType = Constants.CreditCardTokenType Then
            outOfBandTokenResolver = Nothing
            Return New CreditCardTokenAuthenticator(creditCardServiceCredentials.CreditCardDataFile)
        End If
        Return MyBase.CreateSecurityTokenAuthenticator(tokenRequirement, outOfBandTokenResolver)
    End Function

    Public Overrides Function CreateSecurityTokenSerializer(ByVal version As SecurityTokenVersion) As SecurityTokenSerializer
        Return New CreditCardSecurityTokenSerializer(version)
    End Function

End Class

Özel güvenlik belirtecini özel istemci ve hizmet kimlik bilgileriyle tümleştirmek için

  1. Özel güvenlik belirteci içeriğini sağlamak ve kimliğini doğrulamak için daha önce oluşturulan özel güvenlik belirteci altyapısı tarafından kullanılan özel belirteç bilgilerinin belirtilmesine izin vermek üzere uygulama için bir API sağlamak üzere özel istemci ve hizmet kimlik bilgileri eklenmelidir. Aşağıdaki örneklerde bunun nasıl yapılabilmesi gösterilmektedir. Özel istemci ve hizmet kimlik bilgileri hakkında daha fazla bilgi için bkz . İzlenecek Yol: Özel İstemci ve Hizmet Kimlik Bilgileri Oluşturma.

    public class CreditCardClientCredentials : ClientCredentials
{
    CreditCardInfo creditCardInfo;

    public CreditCardClientCredentials(CreditCardInfo creditCardInfo)
        : base()
    {
        if (creditCardInfo == null)
        {
            throw new ArgumentNullException("creditCardInfo");
        }

        this.creditCardInfo = creditCardInfo;
    }

    public CreditCardInfo CreditCardInfo
    {
        get { return this.creditCardInfo; }
    }

    protected override ClientCredentials CloneCore()
    {
        return new CreditCardClientCredentials(this.creditCardInfo);
    }

    public override SecurityTokenManager CreateSecurityTokenManager()
    {
        return new CreditCardClientCredentialsSecurityTokenManager(this);
    }
}

    Public Class CreditCardClientCredentials
    Inherits ClientCredentials

    Private _creditCardInfo As CreditCardInfo

    Public Sub New(ByVal creditCardInfo As CreditCardInfo)
        MyBase.New()
        If creditCardInfo Is Nothing Then
            Throw New ArgumentNullException("creditCardInfo")
        End If

        Me._creditCardInfo = creditCardInfo
    End Sub

    Public ReadOnly Property CreditCardInfo() As CreditCardInfo
        Get
            Return Me._creditCardInfo
        End Get
    End Property

    Protected Overrides Function CloneCore() As ClientCredentials
        Return New CreditCardClientCredentials(Me._creditCardInfo)
    End Function

    Public Overrides Function CreateSecurityTokenManager() As SecurityTokenManager
        Return New CreditCardClientCredentialsSecurityTokenManager(Me)
    End Function

End Class

    public class CreditCardServiceCredentials : ServiceCredentials
{
    string creditCardFile;

    public CreditCardServiceCredentials(string creditCardFile)
        : base()
    {
        if (creditCardFile == null)
        {
            throw new ArgumentNullException("creditCardFile");
        }

        this.creditCardFile = creditCardFile;
    }

    public string CreditCardDataFile
    {
        get { return this.creditCardFile; }
    }

    protected override ServiceCredentials CloneCore()
    {
        return new CreditCardServiceCredentials(this.creditCardFile);
    }

    public override SecurityTokenManager CreateSecurityTokenManager()
    {
        return new CreditCardServiceCredentialsSecurityTokenManager(this);
    }
}

    Public Class CreditCardServiceCredentials
    Inherits ServiceCredentials

    Private creditCardFile As String

    Public Sub New(ByVal creditCardFile As String)
        MyBase.New()
        If creditCardFile Is Nothing Then
            Throw New ArgumentNullException("creditCardFile")
        End If

        Me.creditCardFile = creditCardFile
    End Sub

    Public ReadOnly Property CreditCardDataFile() As String
        Get
            Return Me.creditCardFile
        End Get
    End Property

    Protected Overrides Function CloneCore() As ServiceCredentials
        Return New CreditCardServiceCredentials(Me.creditCardFile)
    End Function

    Public Overrides Function CreateSecurityTokenManager() As SecurityTokenManager
        Return New CreditCardServiceCredentialsSecurityTokenManager(Me)
    End Function

End Class

Daha önce oluşturulan özel güvenlik belirteci parametreleri sınıfı, WCF güvenlik çerçevesine bir hizmetle iletişim kurarken özel bir güvenlik belirtecinin kullanılması gerektiğini söylemek için kullanılır. Aşağıdaki yordamda bunun nasıl yapılabilmesi gösterilmektedir.

Özel güvenlik belirtecini bağlamayla tümleştirmek için

  1. Özel güvenlik belirteci parametreleri sınıfı, sınıfında kullanıma sunulan SecurityBindingElement belirteç parametre koleksiyonlarından birinde belirtilmelidir. Aşağıdaki örnek tarafından SignedEncrypteddöndürülen koleksiyonu kullanır. Kod, içeriği otomatik olarak imzalanmış ve şifrelenmiş olarak istemciden hizmete gönderilen her iletiye kredi kartı özel belirtecini ekler.

    public static class BindingHelper
{
    public static Binding CreateCreditCardBinding()
    {
        HttpTransportBindingElement httpTransport = new HttpTransportBindingElement();

        // The message security binding element is configured to require a credit card
        // token that is encrypted with the service's certificate.
        SymmetricSecurityBindingElement messageSecurity = new SymmetricSecurityBindingElement();
        messageSecurity.EndpointSupportingTokenParameters.SignedEncrypted.Add(new CreditCardTokenParameters());
        X509SecurityTokenParameters x509ProtectionParameters = new X509SecurityTokenParameters();
        x509ProtectionParameters.InclusionMode = SecurityTokenInclusionMode.Never;
        messageSecurity.ProtectionTokenParameters = x509ProtectionParameters;
        return new CustomBinding(messageSecurity, httpTransport);
    }
}

    Public NotInheritable Class BindingHelper

    Private Sub New()
    End Sub

    Public Shared Function CreateCreditCardBinding() As Binding
        Dim httpTransport As New HttpTransportBindingElement()

        ' The message security binding element is configured to require a credit card
        ' token that is encrypted with the service's certificate. 
        Dim messageSecurity As New SymmetricSecurityBindingElement()
        messageSecurity.EndpointSupportingTokenParameters.SignedEncrypted.Add(New CreditCardTokenParameters())
        Dim x509ProtectionParameters As New X509SecurityTokenParameters()
        x509ProtectionParameters.InclusionMode = SecurityTokenInclusionMode.Never
        messageSecurity.ProtectionTokenParameters = x509ProtectionParameters
        Return New CustomBinding(messageSecurity, httpTransport)
    End Function

End Class

Bu konu başlığında, özel belirteç uygulamak ve kullanmak için gereken çeşitli kod parçaları gösterilmektedir. Tüm bu kod parçalarının nasıl bir araya geldiğiyle ilgili tam bir örnek görmek için Bkz . Özel Belirteç.

Ayrıca bkz.