SecurityToken Klas

Definitie

public ref class SecurityToken abstract

public abstract class SecurityToken

type SecurityToken = class

Public MustInherit Class SecurityToken

Overname

Object

SecurityToken

Afgeleid

System.IdentityModel.Tokens.EncryptedSecurityToken

System.IdentityModel.Tokens.GenericXmlSecurityToken

System.IdentityModel.Tokens.KerberosRequestorSecurityToken

System.IdentityModel.Tokens.RsaSecurityToken

System.IdentityModel.Tokens.Saml2SecurityToken

Meer…

Voorbeelden

De codevoorbeelden die in de SecurityToken onderwerpen worden gebruikt, worden uit het Custom Token voorbeeld genomen. Dit voorbeeld bevat aangepaste klassen waarmee eenvoudige webtokens (SWT) kunnen worden verwerkt. Het bevat een implementatie van een SimpleWebToken klasse en een SimpleWebTokenHandler klasse, evenals andere klassen die SWT-tokens ondersteunen. Zie de WIF-codevoorbeeldindex voor informatie over dit voorbeeld en andere voorbeelden die beschikbaar zijn voor WIF en waar u ze kunt downloaden. De volgende code toont de implementatie van de SimpleWebToken klasse. Deze klasse breidt zich uit SecurityToken.

/// <summary>
/// Defines the set of constants for the Simple Web Token.
/// </summary>
public static class SimpleWebTokenConstants
{
    public const string Audience = "Audience";
    public const string ExpiresOn = "ExpiresOn";
    public const string Id = "Id";
    public const string Issuer = "Issuer";
    public const string Signature = "HMACSHA256";
    public const string ValidFrom = "ValidFrom";
    public const string ValueTypeUri = "http://schemas.xmlsoap.org/ws/2009/11/swt-token-profile-1.0";     
}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.IdentityModel.Tokens;

namespace SimpleWebToken
{
    /// <summary>
    /// This class represents the token format for the SimpleWebToken.
    /// </summary>
    public class SimpleWebToken : SecurityToken
    {
        public static DateTime SwtBaseTime = new DateTime( 1970, 1, 1, 0, 0, 0, 0 ); // per SWT psec

        NameValueCollection _properties;
        string _serializedToken;

        /// <summary>
        /// Initializes a new instance of the <see cref="SimpleWebToken"/> class.
        /// This is an internal constructor that is only called from the <see cref="SimpleWebTokenHandler"/> when reading a token received from the wire.
        /// </summary>
        /// <param name="properties">The collection representing all the key value pairs in the token.</param>
        /// <param name="serializedToken">The serialized form of the token.</param>
        internal SimpleWebToken( NameValueCollection properties, string serializedToken )
            : this(properties)
        {
            _serializedToken = serializedToken;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SimpleWebToken"/> class.
        /// </summary>
        /// <param name="properties">The collection representing all the key value pairs in the token.</param>
        public SimpleWebToken( NameValueCollection properties )
        {
            if ( properties == null )
            {
                throw new ArgumentNullException( "properties" );
            }

            _properties = properties;
        }

        /// <summary>
        /// Gets the Id of the token.
        /// </summary>
        /// <value>The Id of the token.</value>
        public override string Id
        {
            get 
            {
                return _properties[SimpleWebTokenConstants.Id];
            }
        }

        /// <summary>
        /// Gets the keys associated with this token.
        /// </summary>
        /// <value>The keys associated with this token.</value>
        public override ReadOnlyCollection<SecurityKey> SecurityKeys
        {
            get 
            { 
                return new ReadOnlyCollection<SecurityKey>( new List<SecurityKey>() ); 
            }
        }

        /// <summary>
        /// Gets the time from when the token is valid.
        /// </summary>
        /// <value>The time from when the token is valid.</value>
        public override DateTime ValidFrom
        {
            get 
            {
                string validFrom = _properties[SimpleWebTokenConstants.ValidFrom];
                return GetTimeAsDateTime( String.IsNullOrEmpty( validFrom ) ? "0" : validFrom );
            }
        }

        /// <summary>
        /// Gets the time when the token expires.
        /// </summary>
        /// <value>The time up to which the token is valid.</value>
        public override DateTime ValidTo
        {
            get
            {
                string expiryTime = _properties[SimpleWebTokenConstants.ExpiresOn];
                return GetTimeAsDateTime( String.IsNullOrEmpty( expiryTime ) ? "0" : expiryTime );
            }
        }

        /// <summary>
        /// Gets the Audience for the token.
        /// </summary>
        /// <value>The audience of the token.</value>
        public string Audience
        {
            get 
            {
                return _properties[SimpleWebTokenConstants.Audience];
            }
        }

        /// <summary>
        /// Gets the Issuer for the token.
        /// </summary>
        /// <value>The issuer for the token.</value>
        public string Issuer
        {
            get 
            { 
                return _properties[SimpleWebTokenConstants.Issuer]; 
            }
        }

        /// <summary>
        /// Gets the signature for the token.
        /// </summary>
        /// <value>The signature for the token.</value>
        public string Signature
        {
            get 
            { 
                return _properties[SimpleWebTokenConstants.Signature]; 
            }
        }

        /// <summary>
        /// Gets the serialized form of the token if the token was created from its serialized form by the token handler.
        /// </summary>
        /// <value>The serialized form of the token.</value>
        public string SerializedToken
        {
            get
            {
                return _serializedToken;
            }
        }

        /// <summary>
        /// Creates a copy of all key value pairs of the token.
        /// </summary>
        /// <returns>A copy of all the key value pairs in the token.</returns>
        public NameValueCollection GetAllProperties()
        {
            return new NameValueCollection( _properties );
        }

        /// <summary>
        /// Converts the time in seconds to a <see cref="DateTime"/> object based on the base time 
        /// defined by the Simple Web Token.
        /// </summary>
        /// <param name="expiryTime">The time in seconds.</param>
        /// <returns>The time as a <see cref="DateTime"/> object.</returns>
        protected virtual DateTime GetTimeAsDateTime( string expiryTime )
        {
            long totalSeconds = 0;
            if ( !long.TryParse( expiryTime, out totalSeconds ) )
            {
                throw new SecurityTokenException("Invalid expiry time. Expected the time to be in seconds passed from 1 January 1970.");
            }

            long maxSeconds = (long)( DateTime.MaxValue - SwtBaseTime ).TotalSeconds - 1;
            if ( totalSeconds > maxSeconds )
            {
                totalSeconds = maxSeconds;
            }

            return SwtBaseTime.AddSeconds( totalSeconds );
        } 
    }    
}

Opmerkingen

Gebruik een beveiligingstoken om verificatiereferenties op te geven of om een bericht te beveiligen.

Een beveiligingstoken kan worden gebruikt om verificatiereferenties, cryptografisch sleutelmateriaal of, in het geval van een beveiligingstoken dat is uitgegeven door een beveiligingstokenservice (STS), een verzameling claims over een onderwerp op te geven. Alle beveiligingstokens zijn afgeleid van de SecurityToken klasse.

Vanaf .NET 4.5 is Windows Identity Foundation (WIF) volledig geïntegreerd in het .NET Framework en zijn de klassen die worden weergegeven door WIF de voorkeursmethode voor het verwerken van beveiligingstokens in uw code. In WIF worden beveiligingstokens geserialiseerd en gedeserialiseerd naar en van hun XML-weergave en worden gevalideerd met behulp van klassen die zijn afgeleid van de SecurityTokenHandler basisklasse. Het valideren van een token houdt niet alleen in dat het token geldig is, maar ook een ClaimsIdentity exemplaar retourneert van het token dat kan worden gebruikt bij het nemen van verificatie- en autorisatiebeslissingen. De ClaimsIdentity methode wordt samengesteld door de implementatie van de tokenhandler van de ValidateToken methode van de claims in het token en van claims die intrinsiek zijn voor het tokentype zelf.

WIF wordt geleverd met ondersteuning voor de volgende typen beveiligingstokens:

• Saml2SecurityToken: Vertegenwoordigt een beveiligingstoken dat is gebaseerd op een SAML 2.0-assertie. Dit tokentype wordt doorgaans uitgegeven door een beveiligingstokenservice als reactie op een WS-Trust of WS-Federation aanvraag voor beveiligingstokens (RST).

• SamlSecurityToken: Vertegenwoordigt een beveiligingstoken dat is gebaseerd op een SAML 1.1-assertie. Dit tokentype wordt doorgaans uitgegeven door een beveiligingstokenservice als reactie op een WS-Trust of WS-Federation aanvraag voor beveiligingstokens (RST).

• KerberosRequestorSecurityToken en KerberosReceiverSecurityToken: vertegenwoordigt een beveiligingstoken dat is gebaseerd op een Kerberos-ticket dat wordt ontvangen of verzonden in een SOAP-bericht

• RsaSecurityToken: Vertegenwoordigt een beveiligingstoken dat is gebaseerd op de sleutel die wordt gemaakt met behulp van het RSA-algoritme.

• SessionSecurityToken: Vertegenwoordigt een beveiligingstoken dat informatie over een sessie bevat.

• UserNameSecurityToken: Vertegenwoordigt een beveiligingstoken dat is gebaseerd op een gebruikersnaam en wachtwoord.

• WindowsSecurityToken: Vertegenwoordigt een beveiligingstoken dat is gebaseerd op de identiteit van een Windows domein of gebruikersaccount.

• X509SecurityToken: Vertegenwoordigt een beveiligingstoken dat is gebaseerd op een X.509-certificaat.

• X509WindowsSecurityToken: Vertegenwoordigt een beveiligingstoken dat is gebaseerd op een X.509-certificaat dat is toegewezen aan een Windows domeingebruiker of lokale computergebruikersaccount.

Twee andere beveiligingstokenklassen GenericXmlSecurityToken en EncryptedSecurityTokenkunnen worden gebruikt om algemene zaken af te handelen.

In grote lijnen vallen beveiligingstokens in drie hoofdcategorieën:

• Tokens die cryptografisch sleutelmateriaal bevatten of ernaar verwijzen. De typen X509SecurityToken worden bijvoorbeeld RsaSecurityToken vaak gebruikt voor dit doel.

• Tokens die referenties vertegenwoordigen voor gebruikers die al zijn geverifieerd. Bijvoorbeeld, het UserNameSecurityToken, WindowsSecurityTokenen, in het geval van een gebruiker geverifieerd met behulp van een certificaat, de X509SecurityToken typen.

• Tokens die worden uitgegeven door een beveiligingstokenservice (STS) in reactie op een beveiligingstokenaanvraag met behulp van het WS-Trust- of WS-Federation-protocol. Deze worden meestal geretourneerd in een wst:RequestSecurityTokenResponse XML-fragment. De Saml2SecurityToken en SamlSecurityToken typen worden meestal gebruikt om deze tokens weer te geven.

Een speciaal tokentype, de SessionSecurityToken, bevat informatie die nodig is om een principal opnieuw te maken bij het gebruik van sessies in actieve of passieve scenario's.

Als u functionaliteit wilt toevoegen aan bestaande tokentypen, kunt u afleiden van het specifieke type en de bijbehorende tokenhandler om nieuwe elementen te ondersteunen die u aan het token toevoegt. Als u ondersteuning wilt toevoegen voor nieuwe tokentypen, kunt u rechtstreeks uit de SecurityToken klasse afleiden. Wanneer u dit doet, moet u ook een tokenhandlerklasse maken door deze af te leiden van de SecurityTokenHandler klasse. Afhankelijk van hoe uw token moet worden gebruikt, moet u mogelijk ook een aangepast token-resolver maken door de klasse af te leiden IssuerTokenResolver , evenals een of meer aangepaste sleutel-id-componenttypen door deze te afleiden van de SecurityKeyIdentifierClause klasse.

Notities voor uitvoerders

U moet de Ideigenschappen , SecurityKeysen ValidFromValidTo eigenschappen overschrijven. De CanCreateKeyIdentifierClause<T>(), CreateKeyIdentifierClause<T>()en MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) methoden ondersteunen alle sleutel-id's van het typeLocalIdKeyIdentifierClause. U moet deze methoden overschrijven om andere typen sleutel-id's in uw afgeleide klasse te ondersteunen.

Zie ook

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause