SecurityTokenHandler.ValidateToken(SecurityToken) Methode

Referenz

Definition

Namespace:: System.IdentityModel.Tokens

Assembly:: System.IdentityModel.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Validiert beim Überschreiben in einer abgeleiteten Klasse das angegebene Sicherheitstoken. Das Token muss von dem von der abgeleiteten Klasse verarbeiteten Typ sein.

public:
 virtual System::Collections::ObjectModel::ReadOnlyCollection<System::Security::Claims::ClaimsIdentity ^> ^ ValidateToken(System::IdentityModel::Tokens::SecurityToken ^ token);

public virtual System.Collections.ObjectModel.ReadOnlyCollection<System.Security.Claims.ClaimsIdentity> ValidateToken (System.IdentityModel.Tokens.SecurityToken token);

abstract member ValidateToken : System.IdentityModel.Tokens.SecurityToken -> System.Collections.ObjectModel.ReadOnlyCollection<System.Security.Claims.ClaimsIdentity>
override this.ValidateToken : System.IdentityModel.Tokens.SecurityToken -> System.Collections.ObjectModel.ReadOnlyCollection<System.Security.Claims.ClaimsIdentity>

Public Overridable Function ValidateToken (token As SecurityToken) As ReadOnlyCollection(Of ClaimsIdentity)

Parameter

token: SecurityToken

Das zu validierende Token.

Gibt zurück

ReadOnlyCollection<ClaimsIdentity>

Die Identitäten im Token.

Beispiele

Der folgende Code zeigt eine Außerkraftsetzung der ValidateToken -Methode für einen Sicherheitstokenhandler, der einfache Webtoken (SWT) verarbeitet. Der Code stammt aus dem CustomToken Beispiel. Informationen zu diesem Beispiel und anderen für WIF verfügbaren Beispielen sowie zu den Informationen zum Herunterladen finden Sie unter WIF-Codebeispielindex.

/// <summary>
/// This method validates the Simple Web Token.
/// </summary>
/// <param name="token">A simple web token.</param>
/// <returns>A Claims Collection which contains all the claims from the token.</returns>
public override ReadOnlyCollection<ClaimsIdentity> ValidateToken(SecurityToken token)
{
    if ( token == null )
    {
        throw new ArgumentNullException( "token" );
    }

    SimpleWebToken simpleWebToken = token as SimpleWebToken;
    if ( simpleWebToken == null )
    {
        throw new ArgumentException("The token provided must be of type SimpleWebToken.");                    
    }

    if ( DateTime.Compare( simpleWebToken.ValidTo.Add( Configuration.MaxClockSkew ), DateTime.UtcNow ) <= 0 )
    {
        throw new SecurityTokenExpiredException("The incoming token has expired. Get a new access token from the Authorization Server.");
    }

    ValidateSignature( simpleWebToken );
 
    ValidateAudience( simpleWebToken.Audience );
 
    ClaimsIdentity claimsIdentity = CreateClaims( simpleWebToken );
   
    if (this.Configuration.SaveBootstrapContext)
    {
        claimsIdentity.BootstrapContext = new BootstrapContext(simpleWebToken.SerializedToken);
    }

    List<ClaimsIdentity> claimCollection = new List<ClaimsIdentity>(new ClaimsIdentity[] { claimsIdentity });
    return claimCollection.AsReadOnly();
}

Der folgende Code zeigt CreateClaims die Methode, die aus der Außerkraftsetzung der ValidateToken Methode im vorherigen Beispiel aufgerufen wird. Diese Methode gibt ein ClaimsIdentity Objekt zurück, das aus den Ansprüchen im Token erstellt wird. Der Code stammt aus dem CustomToken Beispiel. Informationen zu diesem Beispiel und anderen für WIF verfügbaren Beispielen sowie zu den Informationen zum Herunterladen finden Sie unter WIF-Codebeispielindex.

/// <summary>Creates <see cref="Claim"/>'s from the incoming token.
/// </summary>
/// <param name="simpleWebToken">The incoming <see cref="SimpleWebToken"/>.</param>
/// <returns>A <see cref="ClaimsIdentity"/> created from the token.</returns>
protected virtual ClaimsIdentity CreateClaims( SimpleWebToken simpleWebToken )
{
    if ( simpleWebToken == null )
    {
        throw new ArgumentNullException( "simpleWebToken" );
    }

    NameValueCollection tokenProperties = simpleWebToken.GetAllProperties();
    if ( tokenProperties == null )
    {
        throw new SecurityTokenValidationException( "No claims can be created from this Simple Web Token." );
    }

    if ( Configuration.IssuerNameRegistry == null )
    {
        throw new InvalidOperationException( "The Configuration.IssuerNameRegistry property of this SecurityTokenHandler is set to null. Tokens cannot be validated in this state." );
    }

    string normalizedIssuer = Configuration.IssuerNameRegistry.GetIssuerName( simpleWebToken );

    ClaimsIdentity identity = new ClaimsIdentity(AuthenticationTypes.Federation);
    
    foreach ( string key in tokenProperties.Keys )
    {
        if ( ! IsReservedKeyName(key) &&  !string.IsNullOrEmpty( tokenProperties[key] ) )
        {
            identity.AddClaim( new Claim( key, tokenProperties[key], ClaimValueTypes.String, normalizedIssuer ) );
            if ( key == AcsNameClaimType )
            {
                // add a default name claim from the Name identifier claim.
                identity.AddClaim( new Claim( DefaultNameClaimType, tokenProperties[key], ClaimValueTypes.String, normalizedIssuer ) );
            }
        }
    }

    return identity;
}

Der folgende Code zeigt ValidateSignature die Methode, die über die Außerkraftsetzung der ValidateToken Methode im einfachen Webtokenhandler aufgerufen wird. Diese Methode überprüft die Signatur für das Token mithilfe des konfigurierten IssuerTokenResolver. Der Code stammt aus dem CustomToken Beispiel. Informationen zu diesem Beispiel und anderen für WIF verfügbaren Beispielen sowie zu den Informationen zum Herunterladen finden Sie unter WIF-Codebeispielindex.

/// <summary>
/// Validates the signature on the incoming token.
/// </summary>
/// <param name="simpleWebToken">The incoming <see cref="SimpleWebToken"/>.</param>
protected virtual void ValidateSignature( SimpleWebToken simpleWebToken )
{
    if ( simpleWebToken == null )
    {
        throw new ArgumentNullException( "simpleWebToken" );
    }

    if ( String.IsNullOrEmpty( simpleWebToken.SerializedToken ) || String.IsNullOrEmpty( simpleWebToken.Signature ) )
    {
        throw new SecurityTokenValidationException( "The token does not have a signature to verify" );
    }

    string serializedToken = simpleWebToken.SerializedToken;           
    string unsignedToken = null;

    // Find the last parameter. The signature must be last per SWT specification.
    int lastSeparator = serializedToken.LastIndexOf( ParameterSeparator );

    // Check whether the last parameter is an hmac.
    if ( lastSeparator > 0 )
    {
        string lastParamStart = ParameterSeparator + SimpleWebTokenConstants.Signature + "=";
        string lastParam = serializedToken.Substring( lastSeparator );

        // Strip the trailing hmac to obtain the original unsigned string for later hmac verification.               
        if ( lastParam.StartsWith( lastParamStart, StringComparison.Ordinal ) )
        {
            unsignedToken = serializedToken.Substring( 0, lastSeparator );
        }
    }

    SimpleWebTokenKeyIdentifierClause clause = new SimpleWebTokenKeyIdentifierClause(simpleWebToken.Audience);
    InMemorySymmetricSecurityKey securityKey = null;
    try
    {
        securityKey = (InMemorySymmetricSecurityKey)this.Configuration.IssuerTokenResolver.ResolveSecurityKey(clause);
    }
    catch (InvalidOperationException)
    {
        throw new SecurityTokenValidationException( "A Symmetric key was not found for the given key identifier clause.");
    }

    string generatedSignature = GenerateSignature( unsignedToken, securityKey.GetSymmetricKey() );

    if ( string.CompareOrdinal( generatedSignature, simpleWebToken.Signature ) != 0 )
    {
        throw new SecurityTokenValidationException( "The signature on the incoming token is invalid.") ;
    }
}

/// <summary>
/// Generates an HMACSHA256 signature for a given string and key.
/// </summary>
/// <param name="unsignedToken">The token to be signed.</param>
/// <param name="signingKey">The key used to generate the signature.</param>
/// <returns>The generated signature.</returns>
protected static string GenerateSignature(string unsignedToken, byte[] signingKey)
{
    using (HMACSHA256 hmac = new HMACSHA256(signingKey))
    {
        byte[] signatureBytes = hmac.ComputeHash(Encoding.ASCII.GetBytes(unsignedToken));
        string signature = HttpUtility.UrlEncode(Convert.ToBase64String(signatureBytes));

        return signature;
    }
}

Der folgende Code zeigt ValidateAudience die Methode, die über die Außerkraftsetzung der ValidateToken Methode im einfachen Webtokenhandler aufgerufen wird. Diese Methode überprüft die im Token enthaltene Zielgruppe anhand der in der Konfiguration angegebenen Benutzergruppen-URIs. Der Code stammt aus dem CustomToken Beispiel. Informationen zu diesem Beispiel und anderen für WIF verfügbaren Beispielen sowie zu den Informationen zum Herunterladen finden Sie unter WIF-Codebeispielindex.

/// <summary>
/// Validates the audience of the incoming token with those specified in configuration.
/// </summary>
/// <param name="tokenAudience">The audience of the incoming token.</param>
protected virtual void ValidateAudience( string tokenAudience )
{
    if ( Configuration.AudienceRestriction.AudienceMode != AudienceUriMode.Never )
    {
        if ( String.IsNullOrEmpty( tokenAudience ) )
        {
            throw new SecurityTokenValidationException("The incoming token does not have a valid audience Uri and the Audience Restriction is not set to 'None'.");
        }

        if ( Configuration.AudienceRestriction.AllowedAudienceUris.Count == 0 )
        {
            throw new InvalidOperationException( " Audience Restriction is not set to 'None' but no valid audience URI's are configured." );
        }

        IList<Uri> allowedAudienceUris = Configuration.AudienceRestriction.AllowedAudienceUris;
        
        Uri audienceUri = null;

        Uri.TryCreate(tokenAudience, UriKind.RelativeOrAbsolute, out audienceUri);
        
        // Strip off any query string or fragment. 
        Uri audienceLeftPart;

        if ( audienceUri.IsAbsoluteUri )
        {
            audienceLeftPart = new Uri( audienceUri.GetLeftPart( UriPartial.Path ) );
        }
        else
        {
            Uri baseUri = new Uri( "http://www.example.com" );
            Uri resolved = new Uri( baseUri, tokenAudience );
            audienceLeftPart = baseUri.MakeRelativeUri( new Uri( resolved.GetLeftPart( UriPartial.Path ) ) );
        }

        if ( !allowedAudienceUris.Contains( audienceLeftPart ) )
        {
            throw new AudienceUriValidationFailedException(
                    "The Audience Uri of the incoming token is not present in the list of permitted Audience Uri's.");
        }
    }
}

Hinweise

Standardmäßig löst diese Methode eine Ausnahme aus NotImplementedException .

Die ValidateToken -Methode wird von der Infrastruktur aufgerufen, um die Ansprüche aus dem deserialisierten Sicherheitstoken zu überprüfen und zu extrahieren. Diese Ansprüche werden in der Auflistung von ClaimsIdentity Objekten zurückgegeben, die von der -Methode zurückgegeben werden. Im typischen Fall enthält diese Sammlung eine einzelne Identität.

In abgeleiteten Klassen umfasst die Validierung in der Regel die Überprüfung der im Token angegebenen Zielgruppe mit den In der SecurityTokenHandlerConfiguration.AudienceRestriction -Eigenschaft des Tokenhandlerkonfigurationsobjekts angegebenen Configuration Zielgruppen-URIs. Diese URIs werden in der Regel in der Konfigurationsdatei unter dem <audienceUris-Element> festgelegt. Wenn die Zielgruppe nicht überprüft werden kann, sollte eine AudienceUriValidationFailedException Ausnahme ausgelöst werden.

Bei der Verarbeitung des Tokens wird der Aussteller in der Regel überprüft, indem das Ausstellertoken an eine der GetIssuerName Methoden für das IssuerNameRegistry Objekt übergeben wird, das über die Configuration -Eigenschaft für den Handler konfiguriert ist. Die Ausstellernamenregistrierung wird in der Regel über das <issuerNameRegistry-Element> in der Konfigurationsdatei konfiguriert. Gibt GetIssuerName den Namen des Ausstellers zurück. Dieser Name sollte verwendet werden, um die Claim.Issuer Eigenschaft in Ansprüchen festzulegen, die im Token enthalten sind. Wenn die Registrierung des Ausstellernamens keinen Eintrag für das Ausstellertoken enthält, GetIssuerName wird zurückgegeben null. In diesem Fall wird in der Regel in abgeleiteten Klassen ein SecurityTokenException ausgelöst, aber dieses Verhalten hängt vom Designer der Klasse ab.

Gilt für:

Freigeben über