AsymmetricSecurityProtocolFactory.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 / ServiceModel / System / ServiceModel / Security / AsymmetricSecurityProtocolFactory.cs / 1 / AsymmetricSecurityProtocolFactory.cs

                            //---------------------------------------------------------- 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------

namespace System.ServiceModel.Security 
{
    using System.Collections.ObjectModel; 
    using System.ServiceModel; 
    using System.ServiceModel.Description;
    using System.IdentityModel.Selectors; 
    using System.IdentityModel.Tokens;
    using System.ServiceModel.Channels;
    using System.ServiceModel.Security.Tokens;
 
    class AsymmetricSecurityProtocolFactory : MessageSecurityProtocolFactory
    { 
        SecurityTokenParameters cryptoTokenParameters; 
        SecurityTokenParameters asymmetricTokenParameters;
 
        SecurityTokenProvider recipientAsymmetricTokenProvider;
        ReadOnlyCollection recipientOutOfBandTokenResolverList;
        SecurityTokenAuthenticator recipientCryptoTokenAuthenticator;
 
        bool allowSerializedSigningTokenOnReply;
 
        public AsymmetricSecurityProtocolFactory() 
            : base()
        { 
        }

        internal AsymmetricSecurityProtocolFactory(AsymmetricSecurityProtocolFactory factory)
            : base(factory) 
        {
            this.allowSerializedSigningTokenOnReply = factory.allowSerializedSigningTokenOnReply; 
        } 

        public bool AllowSerializedSigningTokenOnReply 
        {
            get
            {
                return this.allowSerializedSigningTokenOnReply; 
            }
            set 
            { 
                ThrowIfImmutable();
                this.allowSerializedSigningTokenOnReply = value; 
            }
        }

        public SecurityTokenParameters AsymmetricTokenParameters 
        {
            get 
            { 
                return this.asymmetricTokenParameters;
            } 
            set
            {
                ThrowIfImmutable();
                this.asymmetricTokenParameters = value; 
            }
        } 
 
        public SecurityTokenProvider RecipientAsymmetricTokenProvider
        { 
            get
            {
                this.CommunicationObject.ThrowIfNotOpened();
                return this.recipientAsymmetricTokenProvider; 
            }
        } 
 
        public SecurityTokenAuthenticator RecipientCryptoTokenAuthenticator
        { 
            get
            {
                this.CommunicationObject.ThrowIfNotOpened();
                return this.recipientCryptoTokenAuthenticator; 
            }
        } 
 
        public ReadOnlyCollection RecipientOutOfBandTokenResolverList
        { 
            get
            {
                this.CommunicationObject.ThrowIfNotOpened();
                return this.recipientOutOfBandTokenResolverList; 
            }
        } 
 

        public SecurityTokenParameters CryptoTokenParameters 
        {
            get
            {
                return this.cryptoTokenParameters; 
            }
            set 
            { 
                ThrowIfImmutable();
                this.cryptoTokenParameters = value; 
            }
        }

        bool RequiresAsymmetricTokenProviderForForwardDirection 
        {
            get 
            { 
                return ((this.ActAsInitiator && this.ApplyConfidentiality) || (!this.ActAsInitiator && this.RequireConfidentiality));
            } 
        }

        bool RequiresAsymmetricTokenProviderForReturnDirection
        { 
            get
            { 
                return ((this.ActAsInitiator && this.RequireIntegrity) || (!this.ActAsInitiator && this.ApplyIntegrity)); 
            }
        } 

        public override EndpointIdentity GetIdentityOfSelf()
        {
            if (this.SecurityTokenManager is IEndpointIdentityProvider && this.AsymmetricTokenParameters != null) 
            {
                SecurityTokenRequirement requirement = CreateRecipientSecurityTokenRequirement(); 
                this.AsymmetricTokenParameters.InitializeSecurityTokenRequirement(requirement); 
                return ((IEndpointIdentityProvider)this.SecurityTokenManager).GetIdentityOfSelf(requirement);
            } 
            else
            {
                return base.GetIdentityOfSelf();
            } 
        }
 
        public override T GetProperty() 
        {
            if (typeof(T) == typeof(Collection)) 
            {
                Collection result = base.GetProperty>();
                if (this.recipientCryptoTokenAuthenticator is ISecurityContextSecurityTokenCacheProvider)
                { 
                    result.Add(((ISecurityContextSecurityTokenCacheProvider)this.recipientCryptoTokenAuthenticator).TokenCache);
                } 
                return (T) (object) (result); 
            }
            else 
            {
                return base.GetProperty();
            }
        } 

        public override void OnClose(TimeSpan timeout) 
        { 
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            if (!this.ActAsInitiator) 
            {
                if (this.recipientAsymmetricTokenProvider != null)
                {
                    SecurityUtils.CloseTokenProviderIfRequired(this.recipientAsymmetricTokenProvider, timeoutHelper.RemainingTime()); 
                }
                if (this.recipientCryptoTokenAuthenticator != null) 
                { 
                    SecurityUtils.CloseTokenAuthenticatorIfRequired(this.recipientCryptoTokenAuthenticator, timeoutHelper.RemainingTime());
                } 
            }
            base.OnClose(timeoutHelper.RemainingTime());
        }
 
        public override void OnAbort()
        { 
            if (!this.ActAsInitiator) 
            {
                if (this.recipientAsymmetricTokenProvider != null) 
                {
                    SecurityUtils.AbortTokenProviderIfRequired(this.recipientAsymmetricTokenProvider);
                }
                if (this.recipientCryptoTokenAuthenticator != null) 
                {
                    SecurityUtils.AbortTokenAuthenticatorIfRequired(this.recipientCryptoTokenAuthenticator); 
                } 
            }
            base.OnAbort(); 
        }

        protected override SecurityProtocol OnCreateSecurityProtocol(EndpointAddress target, Uri via, object listenerSecurityState, TimeSpan timeout)
        { 
            return new AsymmetricSecurityProtocol(this, target, via);
        } 
 
        public override void OnOpen(TimeSpan timeout)
        { 
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            base.OnOpen(timeoutHelper.RemainingTime());

            // open forward direction 
            if (this.ActAsInitiator)
            { 
                if (this.ApplyIntegrity) 
                {
                    if (this.CryptoTokenParameters == null) 
                    {
                        OnPropertySettingsError("CryptoTokenParameters", true);
                    }
                    if (this.CryptoTokenParameters.RequireDerivedKeys) 
                    {
                        this.ExpectKeyDerivation = true; 
                    } 
                }
            } 
            else
            {
                if (this.CryptoTokenParameters == null)
                { 
                    OnPropertySettingsError("CryptoTokenParameters", true);
                } 
                if (this.CryptoTokenParameters.RequireDerivedKeys) 
                {
                    this.ExpectKeyDerivation = true; 
                }
                SecurityTokenResolver resolver = null;
                if (this.RequireIntegrity)
                { 
                    RecipientServiceModelSecurityTokenRequirement requirement = CreateRecipientSecurityTokenRequirement();
                    this.CryptoTokenParameters.InitializeSecurityTokenRequirement(requirement); 
                    requirement.KeyUsage = SecurityKeyUsage.Signature; 
                    requirement.Properties[ServiceModelSecurityTokenRequirement.MessageDirectionProperty] = MessageDirection.Input;
                    this.recipientCryptoTokenAuthenticator = this.SecurityTokenManager.CreateSecurityTokenAuthenticator(requirement, out resolver); 
                     Open("RecipientCryptoTokenAuthenticator", true, this.recipientCryptoTokenAuthenticator, timeoutHelper.RemainingTime());
                }
                if (resolver != null)
                { 
                    Collection tmp = new Collection();
                    tmp.Add(resolver); 
                    this.recipientOutOfBandTokenResolverList = new ReadOnlyCollection(tmp); 
                }
                else 
                {
                    this.recipientOutOfBandTokenResolverList = EmptyReadOnlyCollection.Instance;
                }
            } 

            if (this.RequiresAsymmetricTokenProviderForForwardDirection || this.RequiresAsymmetricTokenProviderForReturnDirection) 
            { 
                if (this.AsymmetricTokenParameters == null)
                { 
                    OnPropertySettingsError("AsymmetricTokenParameters", this.RequiresAsymmetricTokenProviderForForwardDirection);
                }
                else if (this.AsymmetricTokenParameters.RequireDerivedKeys)
                { 
                    this.ExpectKeyDerivation = true;
                } 
                if (!this.ActAsInitiator) 
                {
                    RecipientServiceModelSecurityTokenRequirement requirement = CreateRecipientSecurityTokenRequirement(); 
                    this.AsymmetricTokenParameters.InitializeSecurityTokenRequirement(requirement);
                    requirement.KeyUsage = (this.RequiresAsymmetricTokenProviderForForwardDirection) ? SecurityKeyUsage.Exchange : SecurityKeyUsage.Signature;
                    requirement.Properties[ServiceModelSecurityTokenRequirement.MessageDirectionProperty] = (this.RequiresAsymmetricTokenProviderForForwardDirection) ? MessageDirection.Input : MessageDirection.Output;
                    this.recipientAsymmetricTokenProvider = this.SecurityTokenManager.CreateSecurityTokenProvider(requirement); 
                    Open("RecipientAsymmetricTokenProvider", this.RequiresAsymmetricTokenProviderForForwardDirection, this.recipientAsymmetricTokenProvider, timeoutHelper.RemainingTime());
                } 
            } 

            if (this.ActAsInitiator && this.AllowSerializedSigningTokenOnReply && this.IdentityVerifier == null) 
            {
                OnPropertySettingsError("IdentityVerifier", false);
            }
        } 
    }
} 

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