SecurityToken Třída

Definice

public ref class SecurityToken abstract

public abstract class SecurityToken

type SecurityToken = class

Public MustInherit Class SecurityToken

Dědičnost

Object

SecurityToken

Odvozené

System.IdentityModel.Tokens.EncryptedSecurityToken

System.IdentityModel.Tokens.GenericXmlSecurityToken

System.IdentityModel.Tokens.KerberosRequestorSecurityToken

System.IdentityModel.Tokens.RsaSecurityToken

System.IdentityModel.Tokens.Saml2SecurityToken

Více…

Příklady

Příklady kódu, které se používají v tématech SecurityToken , jsou převzaty z ukázky Custom Token . Tato ukázka obsahuje vlastní třídy, které umožňují zpracování jednoduchých webových tokenů (SWT). Zahrnuje implementaci SimpleWebToken třídy a SimpleWebTokenHandler třídy a také dalších tříd, které podporují tokeny SWT. Informace o této ukázce a dalších ukázkách dostupných pro WIF a o tom, kde je stáhnout, najdete v tématu Index ukázek kódu WIF. Následující kód ukazuje implementaci SimpleWebToken třídy. Tato třída rozšiřuje 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 );
        } 
    }    
}

Poznámky

Token zabezpečení použijte k zadání přihlašovacích údajů pro ověřování nebo k ochraně zprávy.

Token zabezpečení lze použít k poskytnutí přihlašovacích údajů pro ověřování, materiálu kryptografického klíče nebo v případě tokenu zabezpečení vydaného službou tokenů zabezpečení (STS) ke kolekci deklarací identity o předmětu. Všechny tokeny zabezpečení jsou odvozeny SecurityToken od třídy .

Počínaje verzí .NET 4.5 je technologie Windows Identity Foundation (WIF) plně integrovaná do rozhraní .NET Framework a třídy vystavené technologií WIF jsou upřednostňovanou metodou zpracování tokenů zabezpečení ve vašem kódu. Ve WIF jsou tokeny zabezpečení serializovány a deserializovány do a z jejich reprezentace XML a jsou ověřeny pomocí tříd odvozených ze SecurityTokenHandler základní třídy. Ověření tokenu zahrnuje nejen ověření platnosti tokenu, ale také vrácení ClaimsIdentity instance z tokenu, která se dá použít při rozhodování o ověřování a autorizaci. Objekt ClaimsIdentity je vytvořen implementací metody obslužné rutiny tokenu ValidateToken z deklarací identity obsažených v tokenu a také z deklarací identity, které jsou vnitřní pro samotný typ tokenu.

WiF se dodává s podporou následujících typů tokenů zabezpečení:

• Saml2SecurityToken: Představuje token zabezpečení, který je založený na kontrolním výrazu SAML 2.0. Tento typ tokenu obvykle vydává služba tokenů zabezpečení v reakci na WS-Trust nebo WS-Federation žádost o token zabezpečení (RST).

• SamlSecurityToken: Představuje token zabezpečení, který je založen na kontrolním výrazu SAML 1.1. Tento typ tokenu obvykle vydává služba tokenů zabezpečení v reakci na WS-Trust nebo WS-Federation žádost o token zabezpečení (RST).

• KerberosRequestorSecurityToken and KerberosReceiverSecurityToken: Představuje token zabezpečení založený na lístku protokolu Kerberos, který je přijat nebo odeslán ve zprávě SOAP.

• RsaSecurityToken: Představuje token zabezpečení, který je založen na klíči vytvořeném pomocí algoritmu RSA.

• SessionSecurityToken: Představuje token zabezpečení, který obsahuje informace o relaci.

• UserNameSecurityToken: Představuje token zabezpečení, který je založený na uživatelském jménu a hesle.

• WindowsSecurityToken: Představuje token zabezpečení, který je založen na identitě domény systému Windows nebo uživatelského účtu.

• X509SecurityToken: Představuje token zabezpečení, který je založen na certifikátu X.509.

• X509WindowsSecurityToken: Představuje token zabezpečení, který je založen na certifikátu X.509, který je mapován na účet uživatele domény systému Windows nebo místního počítače.

Ke zpracování obecných případů je možné použít dvě další třídy GenericXmlSecurityTokenEncryptedSecurityTokentokenů zabezpečení a .

Obecně řečeno tokeny zabezpečení spadají do tří hlavních kategorií:

• Tokeny, které nesou nebo odkazují na kryptografický klíč. K tomuto účelu RsaSecurityToken se často používají například typy a X509SecurityToken .

• Tokeny, které představují přihlašovací údaje pro uživatele, kteří již byli ověřeni. Například UserNameSecurityToken, WindowsSecurityTokena, v případě uživatele ověřeného pomocí certifikátu, typy X509SecurityToken .

• Tokeny vydané službou tokenů zabezpečení (STS) v reakci na žádost o token zabezpečení pomocí protokolu WS-Trust nebo WS-Federation. Ty se obvykle vrací ve fragmentu wst:RequestSecurityTokenResponse XML. Typy Saml2SecurityToken a SamlSecurityToken se nejčastěji používají k reprezentaci těchto tokenů.

Speciální typ tokenu SessionSecurityToken, , obsahuje informace potřebné k opětovnému vytvoření objektu zabezpečení při použití relací v aktivních nebo pasivních scénářích.

Chcete-li přidat funkce k existujícím typům tokenů, můžete odvodit od konkrétního typu a jeho přidružené obslužné rutiny tokenu, aby se podporovaly všechny nové prvky, které přidáte do tokenu. Pokud chcete přidat podporu pro nové typy tokenů, můžete odvodit přímo z SecurityToken třídy . Když to uděláte, budete také muset vytvořit třídu obslužné rutiny tokenu odvozením z SecurityTokenHandler třídy. V závislosti na způsobu použití tokenu může být také nutné vytvořit vlastní překladač tokenů odvozením z IssuerTokenResolver třídy a jednoho nebo více typů klauzule identifikátoru vlastního SecurityKeyIdentifierClause klíče odvozením z třídy.

Poznámky pro implementátory

Musíte přepsat Idvlastnosti , SecurityKeys, ValidFroma ValidTo . Metody CanCreateKeyIdentifierClause<T>(), CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)a ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) podporují identifikátory klíčů typu LocalIdKeyIdentifierClause. Tyto metody musíte přepsat, aby podporovaly jiné typy identifikátorů klíčů v odvozené třídě.

Konstruktory

Vlastnosti

Metody

Platí pro

Viz také

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause