InfocardClientCredentials.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 / InfocardClientCredentials.cs / 1 / InfocardClientCredentials.cs

                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace Microsoft.InfoCards
{ 
    using System;
    using System.IdentityModel.Tokens; 
    using System.IdentityModel.Selectors; 
    using System.ServiceModel;
    using System.ServiceModel.Description; 
    using System.ServiceModel.Security;
    using System.ServiceModel.Security.Tokens;
    using System.ServiceModel.Dispatcher;
    using IDT = Microsoft.InfoCards.Diagnostics.InfoCardTrace; 

    // 
    // Summary 
    //  This class provides the credentials for authentication using self issued cards
    // 
    internal class InfoCardServiceClientCredentials : ClientCredentials
    {
        InfoCard m_card;
        TokenFactoryCredential m_credentials; 
        bool m_isSelfIssued;
        ProtocolProfile m_protocolProfile; 
 
        RSATokenProvider m_endorsingSigTokenProvider;
 
        //
        // CTOR
        //
        public InfoCardServiceClientCredentials( TokenFactoryCredential creds, ProtocolProfile profile ) 
        {
            m_credentials = creds; 
            m_protocolProfile = profile; 
        }
 
        public InfoCardServiceClientCredentials(InfoCardServiceClientCredentials other, ProtocolProfile profile )
            : base(other)
        {
            m_credentials = other.m_credentials; 
            m_endorsingSigTokenProvider = other.m_endorsingSigTokenProvider;
            m_protocolProfile = profile; 
        } 

        public InfoCard SelectedCard 
        {
            get{ return m_card; }
            set{ m_card = value; }
        } 

        public bool IsSelfIssuedCred 
        { 
            get { return m_isSelfIssued; }
            set { m_isSelfIssued = value; } 
        }

        public RSATokenProvider EndorsingSignatureTokenProvider
        { 
            get { return m_endorsingSigTokenProvider; }
            set { m_endorsingSigTokenProvider = value; } 
        } 

        public ProtocolProfile ProtocolVersionProfile 
        {
            get
            {
                return m_protocolProfile; 
            }
        } 
 
        protected override ClientCredentials CloneCore()
        { 
            return new InfoCardServiceClientCredentials( this, m_protocolProfile );
        }

        public override void ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime behavior) 
        {
        } 
 
        public override SecurityTokenManager CreateSecurityTokenManager()
        { 
            return new InfoCardServiceClientCredentialsSecurityTokenManager(this);
        }

        class InfoCardServiceClientCredentialsSecurityTokenManager : ClientCredentialsSecurityTokenManager 
        {
            InfoCard m_card; 
            TokenFactoryCredential m_credentials; 
            ProtocolProfile m_protocolProfile;
 
            public InfoCardServiceClientCredentialsSecurityTokenManager(InfoCardServiceClientCredentials creds)
                : base(creds)
            {
                m_card = creds.SelectedCard; 
                m_credentials = creds.m_credentials;
                m_protocolProfile = creds.ProtocolVersionProfile; 
            } 

            public override SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement) 
            {
                if (tokenRequirement == null)
                {
                    throw IDT.ThrowHelperArgumentNull("tokenRequirement"); 
                }
 
                string tokenType = tokenRequirement.TokenType; 

                bool needUseKey = null != ((InfoCardServiceClientCredentials)ClientCredentials).EndorsingSignatureTokenProvider; 

                //
                // Check if the credential type that is requested matches the one in the selcted card.
                // If sucessful, return the appropriate tokenprovider. 
                //
                if (IsIssuedSecurityTokenRequirement(tokenRequirement)) 
                { 
                    if (m_credentials.CredentialType != TokenFactoryCredentialType.SelfIssuedCredential)
                    { 
                        throw IDT.ThrowHelperError(new TokenCreationException(SR.GetString(SR.CardDoesNotMatchRequiredAuthType)));
                    }

                    IssuedSecurityTokenParameters itp = tokenRequirement.GetProperty(ServiceModelSecurityTokenRequirement.IssuedSecurityTokenParametersProperty); 
                    EndpointAddress target = tokenRequirement.GetProperty(ServiceModelSecurityTokenRequirement.TargetAddressProperty);
                    if( itp.IssuerAddress != null && Utility.CompareUri( itp.IssuerAddress.Uri, XmlNames.WSIdentity.SelfIssuerUriValue ) ) 
                    { 
                        return new CustomTokenProvider( itp,
                                                        m_card, 
                                                        target,
                                                        ((InfoCardServiceClientCredentials)base.ClientCredentials).IsSelfIssuedCred,
                                                        m_protocolProfile );
                    } 
                    else
                    { 
                        throw IDT.ThrowHelperError(new TokenCreationException(SR.GetString(SR.InvalidIssuerForIssuedToken))); 
                    }
                } 
                else if (tokenType == SecurityTokenTypes.X509Certificate)
                {
                    if (tokenRequirement.KeyUsage == SecurityKeyUsage.Signature)
                    { 
                       if (m_credentials.CredentialType != TokenFactoryCredentialType.X509CertificateCredential)
                       { 
                            throw IDT.ThrowHelperError(new TokenCreationException(SR.GetString(SR.CardDoesNotMatchRequiredAuthType))); 
                       }
                       return new RemoteCryptoTokenProvider(this.ClientCredentials.ClientCertificate.Certificate); 
                    }
                    else
                    {
                        return base.CreateSecurityTokenProvider(tokenRequirement); 
                    }
                } 
                else if (tokenType == ServiceModelSecurityTokenTypes.MutualSslnego) 
                {
                    if (m_credentials.CredentialType != TokenFactoryCredentialType.X509CertificateCredential) 
                    {
                        throw IDT.ThrowHelperError(new TokenCreationException(SR.GetString(SR.CardDoesNotMatchRequiredAuthType)));
                    }
                    return base.CreateSecurityTokenProvider(tokenRequirement); 
                }
                else if (tokenType == ServiceModelSecurityTokenTypes.AnonymousSslnego) 
                { 
                    return base.CreateSecurityTokenProvider(tokenRequirement);
                } 
                else if (tokenType == ServiceModelSecurityTokenTypes.SecureConversation)
                {
                    return base.CreateSecurityTokenProvider(tokenRequirement);
                } 
                else if (tokenType == SecurityTokenTypes.Kerberos || tokenType == ServiceModelSecurityTokenTypes.Spnego)
                { 
                    if (m_credentials.CredentialType != TokenFactoryCredentialType.KerberosCredential) 
                    {
                        throw IDT.ThrowHelperError(new TokenCreationException(SR.GetString(SR.CardDoesNotMatchRequiredAuthType))); 
                    }
                    return base.CreateSecurityTokenProvider(tokenRequirement);
                }
                else if (tokenType == SecurityTokenTypes.UserName) 
                {
                    if (m_credentials.CredentialType != TokenFactoryCredentialType.UserNamePasswordCredential) 
                    { 
                        throw IDT.ThrowHelperError(new TokenCreationException(SR.GetString(SR.CardDoesNotMatchRequiredAuthType)));
                    } 
                    return base.CreateSecurityTokenProvider(tokenRequirement);
                }
                else if (tokenType == ServiceModelSecurityTokenTypes.SspiCredential)
                { 
                    if (m_credentials.CredentialType != TokenFactoryCredentialType.KerberosCredential
                        && m_credentials.CredentialType != TokenFactoryCredentialType.UserNamePasswordCredential) 
                    { 
                        throw IDT.ThrowHelperError(new TokenCreationException(SR.GetString(SR.CardDoesNotMatchRequiredAuthType)));
                    } 
                    return base.CreateSecurityTokenProvider(tokenRequirement);
                }
                else if( tokenType == SecurityTokenTypes.Rsa && needUseKey )
                { 
                    //
                    // If this is being asked for it is to prove posession of a private key associated with a public 
                    // key passed in the UseKey field of an RST. 
                    //
                    InfoCardServiceClientCredentials icClientCreds = (InfoCardServiceClientCredentials)ClientCredentials; 

                    return icClientCreds.EndorsingSignatureTokenProvider;

                } 
                else
                { 
                    return base.CreateSecurityTokenProvider( tokenRequirement ); 
                }
            } 
        }
    }
}

// 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