Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.IdentityModel/System/IdentityModel/Tokens/Saml2SecurityToken.cs

@@ -0,0 +1,164 @@
+//-----------------------------------------------------------------------
+// <copyright file="Saml2SubjectConfirmation.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace System.IdentityModel.Tokens
+{
+    using System;
+    using System.Collections.ObjectModel;
+    
+    /// <summary>
+    /// A security token backed by a SAML2 assertion.
+    /// </summary>
+    public class Saml2SecurityToken : SecurityToken
+    {
+        private Saml2Assertion assertion;
+        private ReadOnlyCollection<SecurityKey> keys;
+        private SecurityToken issuerToken;
+
+        /// <summary>
+        /// Initializes an instance of <see cref="Saml2SecurityToken"/> from a <see cref="Saml2Assertion"/>.
+        /// </summary>
+        /// <param name="assertion">A <see cref="Saml2Assertion"/> to initialize from.</param>
+        public Saml2SecurityToken(Saml2Assertion assertion)
+            : this(assertion, EmptyReadOnlyCollection<SecurityKey>.Instance, null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="Saml2SecurityToken"/> from a <see cref="Saml2Assertion"/>.
+        /// </summary>
+        /// <param name="assertion">A <see cref="Saml2Assertion"/> to initialize from.</param>
+        /// <param name="keys">A collection of <see cref="SecurityKey"/> to include in the token.</param>
+        /// <param name="issuerToken">A <see cref="SecurityToken"/> representing the issuer.</param>
+        public Saml2SecurityToken(Saml2Assertion assertion, ReadOnlyCollection<SecurityKey> keys, SecurityToken issuerToken)
+        {
+            if (null == assertion)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("assertion");
+            }
+
+            if (null == keys)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("keys");
+            }
+
+            this.assertion = assertion;
+            this.keys = keys;
+            this.issuerToken = issuerToken;
+        }
+
+        /// <summary>
+        /// Gets the <see cref="Saml2Assertion"/> for this token.
+        /// </summary>
+        public Saml2Assertion Assertion
+        {
+            get { return this.assertion; }
+        }
+
+        /// <summary>
+        /// Gets the SecurityToken id.
+        /// </summary>
+        public override string Id
+        {
+            get { return this.assertion.Id.Value; }
+        }
+
+        /// <summary>
+        /// Gets the <see cref="SecurityToken"/> of the issuer.
+        /// </summary>
+        public SecurityToken IssuerToken
+        {
+            get { return this.issuerToken; }
+        }
+
+        /// <summary>
+        /// Gets the collection of <see cref="SecurityKey"/> contained in this token.
+        /// </summary>
+        public override ReadOnlyCollection<SecurityKey> SecurityKeys
+        {
+            get { return this.keys; }
+        }
+
+        /// <summary>
+        /// Gets the time the token is valid from.
+        /// </summary>
+        public override DateTime ValidFrom
+        {
+            get
+            {
+                if (null != this.assertion.Conditions && null != this.assertion.Conditions.NotBefore)
+                {
+                    return this.assertion.Conditions.NotBefore.Value;
+                }
+                else
+                {
+                    return DateTime.MinValue;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the time the token is valid to.
+        /// </summary>
+        public override DateTime ValidTo
+        {
+            get
+            {
+                if (null != this.assertion.Conditions && null != this.assertion.Conditions.NotOnOrAfter)
+                {
+                    return this.assertion.Conditions.NotOnOrAfter.Value;
+                }
+                else
+                {
+                    return DateTime.MaxValue;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determines if this token matches the keyIdentifierClause.
+        /// </summary>
+        /// <param name="keyIdentifierClause"><see cref="SecurityKeyIdentifierClause"/> to match.</param>
+        /// <returns>True if the keyIdentifierClause is matched. False otherwise.</returns>
+        public override bool MatchesKeyIdentifierClause(SecurityKeyIdentifierClause keyIdentifierClause)
+        {
+            return Saml2AssertionKeyIdentifierClause.Matches(this.Id, keyIdentifierClause)
+                || base.MatchesKeyIdentifierClause(keyIdentifierClause);
+        }
+
+        /// <summary>
+        /// Determines is this token can create a <see cref="SecurityKeyIdentifierClause"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of <see cref="SecurityKeyIdentifierClause"/> to check if creation is possible.</typeparam>
+        /// <returns>'True' if this token can create a <see cref="SecurityKeyIdentifierClause"/> of type T. 'False' otherwise.</returns>
+        public override bool CanCreateKeyIdentifierClause<T>()
+        {
+            return (typeof(T) == typeof(Saml2AssertionKeyIdentifierClause))
+                || base.CanCreateKeyIdentifierClause<T>();
+        }
+
+        /// <summary>
+        /// Creates a <see cref="SecurityKeyIdentifierClause"/> that represents this token. 
+        /// </summary>
+        /// <typeparam name="T">The type of the <see cref="SecurityKeyIdentifierClause"/> to create.</typeparam>
+        /// <returns>A <see cref="SecurityKeyIdentifierClause"/> for this token.</returns>
+        public override T CreateKeyIdentifierClause<T>()
+        {
+            if (typeof(T) == typeof(Saml2AssertionKeyIdentifierClause))
+            {
+                return new Saml2AssertionKeyIdentifierClause(this.assertion.Id.Value) as T;
+            }
+            else if (typeof(T) == typeof(SamlAssertionKeyIdentifierClause))
+            {
+                return new WrappedSaml2AssertionKeyIdentifierClause(new Saml2AssertionKeyIdentifierClause(this.assertion.Id.Value)) as T;
+            }
+            else
+            {
+                return base.CreateKeyIdentifierClause<T>();
+            }
+        }
+    }
+}