SecurityToken Klass

Definition

public ref class SecurityToken abstract

public abstract class SecurityToken

type SecurityToken = class

Public MustInherit Class SecurityToken

Arv

Object

SecurityToken

Härledda

System.IdentityModel.Tokens.EncryptedSecurityToken

System.IdentityModel.Tokens.GenericXmlSecurityToken

System.IdentityModel.Tokens.KerberosRequestorSecurityToken

System.IdentityModel.Tokens.RsaSecurityToken

System.IdentityModel.Tokens.Saml2SecurityToken

Mer…

Exempel

Kodexemplen som används i ämnena SecurityToken tas från Custom Token exemplet. Det här exemplet innehåller anpassade klasser som möjliggör bearbetning av enkla webbtoken (SWT). Den innehåller en implementering av en SimpleWebToken klass och en SimpleWebTokenHandler klass samt andra klasser som stöder SWT-token. Information om det här exemplet och andra exempel som är tillgängliga för WIF och var du kan ladda ned dem finns i WIF Code Sample Index. Följande kod visar implementeringen av SimpleWebToken klassen. Den här klassen utökar 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 );
        } 
    }    
}

Kommentarer

Använd en säkerhetstoken för att ange autentiseringsuppgifter eller för att skydda ett meddelande.

En säkerhetstoken kan användas för att ange autentiseringsuppgifter, kryptografiskt nyckelmaterial eller, om en säkerhetstoken utfärdas av en säkerhetstokentjänst (STS), en samling anspråk om ett ämne. Alla säkerhetstoken härleds från SecurityToken klassen.

Från och med .NET 4.5 har Windows Identity Foundation (WIF) integrerats helt i .NET Framework och de klasser som exponeras av WIF är den bästa metoden för att hantera säkerhetstoken i koden. I WIF serialiseras och deserialiseras säkerhetstoken till och från deras XML-representation och verifieras med hjälp av klasser som härleds från basklassen SecurityTokenHandler . Validering av en token innebär inte bara att säkerställa att token är giltig, utan även att returnera en ClaimsIdentity instans från token som kan användas för att fatta autentiserings- och auktoriseringsbeslut. ClaimsIdentity Konstrueras av tokenhanterarens implementering av ValidateToken metoden från anspråken som finns i token samt från anspråk som är inbyggda i själva tokentypen.

WIF levereras med stöd för följande typer av säkerhetstoken:

• Saml2SecurityToken: Representerar en säkerhetstoken som baseras på en SAML 2.0-försäkran. Den här tokentypen utfärdas vanligtvis av en tjänst för säkerhetstoken som svar på en WS-Trust eller WS-Federation begäran om säkerhetstoken (RST).

• SamlSecurityToken: Representerar en säkerhetstoken som baseras på en SAML 1.1-försäkran. Den här tokentypen utfärdas vanligtvis av en tjänst för säkerhetstoken som svar på en WS-Trust eller WS-Federation begäran om säkerhetstoken (RST).

• KerberosRequestorSecurityToken och KerberosReceiverSecurityToken: Representerar en säkerhetstoken som baseras på en Kerberos-biljett som tas emot eller skickas i ett SOAP-meddelande

• RsaSecurityToken: Representerar en säkerhetstoken som baseras på en nyckel som skapas med hjälp av RSA-algoritmen.

• SessionSecurityToken: Representerar en säkerhetstoken som innehåller information om en session.

• UserNameSecurityToken: Representerar en säkerhetstoken som baseras på ett användarnamn och lösenord.

• WindowsSecurityToken: Representerar en säkerhetstoken som baseras på identiteten för en Windows domän eller användarkonto.

• X509SecurityToken: Representerar en säkerhetstoken som baseras på ett X.509-certifikat.

• X509WindowsSecurityToken: Representerar en säkerhetstoken som baseras på ett X.509-certifikat som är mappat till en Windows domänanvändare eller ett lokalt datoranvändarkonto.

Två andra säkerhetstokenklasser, GenericXmlSecurityToken och EncryptedSecurityToken, kan användas för att hantera allmänna ärenden.

Säkerhetstoken i stort sett delas in i tre huvudkategorier:

• Token som bär eller refererar till kryptografiskt nyckelmaterial. Till exempel används typerna RsaSecurityToken och X509SecurityToken ofta för detta ändamål.

• Token som representerar autentiseringsuppgifter för användare som redan har autentiserats. Till exempel typerna UserNameSecurityToken, WindowsSecurityTokenoch, om en användare autentiseras X509SecurityToken med ett certifikat.

• Token som utfärdas av en säkerhetstokentjänst (STS) som svar på en begäran om säkerhetstoken med hjälp av antingen WS-Trust- eller WS-Federation-protokollet. Dessa returneras vanligtvis i ett wst:RequestSecurityTokenResponse XML-fragment. Typerna Saml2SecurityToken och SamlSecurityToken används oftast för att representera dessa token.

En särskild tokentyp, SessionSecurityToken, innehåller information som krävs för att återskapa ett huvudnamn när du använder sessioner i aktiva eller passiva scenarier.

Om du vill lägga till funktioner i befintliga tokentyper kan du härleda från den specifika typen och dess associerade tokenhanterare för att stödja alla nya element som du lägger till i token. Om du vill lägga till stöd för nya tokentyper kan du härleda direkt från SecurityToken klassen. När du gör detta måste du också skapa en tokenhanterarklass genom att härleda från SecurityTokenHandler klassen. Beroende på hur din token ska användas kan du också behöva skapa en anpassad tokenlösare genom att härleda från IssuerTokenResolver klassen samt en eller flera typer av anpassade nyckelidentifierare genom att härleda från SecurityKeyIdentifierClause klassen.

Anteckningar till implementerare

Du måste åsidosätta Idegenskaperna , SecurityKeys, ValidFromoch ValidTo . Metoderna CanCreateKeyIdentifierClause<T>(), CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)och ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) stöder alla nyckelidentifierare av typen LocalIdKeyIdentifierClause. Du måste åsidosätta dessa metoder för att stödja andra typer av nyckelidentifierare i din härledda klass.

Se även

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause