SelfIssuedAuthProofToken.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / infocard / Service / managed / Microsoft / InfoCards / SelfIssuedAuthProofToken.cs / 1 / SelfIssuedAuthProofToken.cs

                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace Microsoft.InfoCards
{ 
    using System;
    using System.IdentityModel.Selectors; 
    using System.IdentityModel.Tokens; 
    using System.ServiceModel;
    using System.ServiceModel.Security; 
    using System.ServiceModel.Security.Tokens;
    using System.Runtime.InteropServices;
    using System.Security.Cryptography;
    using System.IdentityModel; 
    using System.Security.Cryptography.Xml;
 
    using IDT = Microsoft.InfoCards.Diagnostics.InfoCardTrace; 
    using System.Collections.ObjectModel;
    using System.Collections.Generic; 

    //
    // Summary:
    //  This class implements a proof token that we can hand to indigo 
    //  for purposes of signing (instead of passing for example the raw unencrypted
    //  Saml token) 
    // 
    internal class SelfIssuedAuthProofToken : SecurityToken, IDisposable
    { 
        string m_id;
        DateTime m_expiration;
        ReadOnlyCollection m_securityKeys;
        SecurityKey m_securityKey; 
        bool m_isSymmetric;
        RSACryptoServiceProvider m_publicKey; 
 
        public SelfIssuedAuthProofToken( RSACryptoServiceProvider rsa, DateTime expiration )
            : this( expiration ) 
        {
            m_publicKey = new RSACryptoServiceProvider();

            // 
            // Get the public key from the passed in public/private key pair.  This is used strictly for
            // creating an RsaKeyIdentifierClause 
            // 
            m_publicKey.ImportCspBlob( rsa.ExportCspBlob( false ) );
 
            InitCrypto( new SelfIssuedAuthAsymmetricKey( rsa ) );
        }

        public SelfIssuedAuthProofToken( InMemorySymmetricSecurityKey symKey, DateTime expiration ) 
            : this( expiration )
        { 
            m_isSymmetric = true; 
            InitCrypto( symKey );
        } 

        private SelfIssuedAuthProofToken( DateTime expiration )
            : base()
        { 
            m_id = Guid.NewGuid().ToString();
            m_expiration = expiration.ToUniversalTime(); 
        } 

        public override string Id 
        {
            get { return m_id; }
        }
 
        public override ReadOnlyCollection SecurityKeys
        { 
            get 
            {
                return m_securityKeys; 
            }
        }

        public override DateTime ValidTo 
        {
            get { return m_expiration; } 
        } 

        public override DateTime ValidFrom 
        {
            get { return DateTime.UtcNow; }
        }
 
        private void InitCrypto( SecurityKey securityKey )
        { 
            m_securityKey = securityKey; 
            List securityKeys = new List( 1 );
            securityKeys.Add( securityKey ); 
            m_securityKeys = securityKeys.AsReadOnly();
        }

        public override bool CanCreateKeyIdentifierClause() 
        {
            return typeof(T) == typeof(RsaKeyIdentifierClause); 
        } 

        public override T CreateKeyIdentifierClause() 
        {
            if ( typeof( T ) == typeof( RsaKeyIdentifierClause ) )
            {
                return (T)( (object)new RsaKeyIdentifierClause( m_publicKey ) ); 
            }
 
            return base.CreateKeyIdentifierClause(); 
        }
 
        public override bool MatchesKeyIdentifierClause( SecurityKeyIdentifierClause keyIdentifierClause )
        {
            RsaKeyIdentifierClause rsaKeyIdentifierClause = keyIdentifierClause as RsaKeyIdentifierClause;
            if (rsaKeyIdentifierClause != null) 
                return rsaKeyIdentifierClause.Matches( m_publicKey );
 
            return false; 
        }
 
        public void Dispose()
        {
            //
            // SymmetricKey is NOT IDisposable but RSACryptoServiceProvider is 
            //
            if ( null != m_securityKey && !m_isSymmetric ) 
            { 

                ( ( IDisposable )m_securityKey ).Dispose(); 
                m_securityKey = null;
                m_securityKeys = null;
            }
            if( null != m_publicKey ) 
            {
                ( ( IDisposable )m_publicKey ).Dispose(); 
                m_publicKey = null; 
            }
        } 
    }

}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK