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

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

namespace System.ServiceModel 
{
    using System; 
    using System.ServiceModel.Dispatcher; 
    using System.Diagnostics;
    using System.DirectoryServices; 
    using System.Runtime.InteropServices;
    using System.IdentityModel.Claims;
    using System.IdentityModel.Policy;
    using System.Security.Cryptography; 
    using System.Security.Principal;
    using System.ServiceModel.Diagnostics; 
    using System.ServiceModel.Security; 
    using System.Xml;
    using System.Xml.Serialization; 

    public class SpnEndpointIdentity : EndpointIdentity
    {
        static TimeSpan spnLookupTime = TimeSpan.FromMinutes(1); 

        SecurityIdentifier spnSid; 
        bool hasSpnSidBeenComputed; 

        Object thisLock = new Object(); 

        static Object typeLock = new Object();
        static DirectoryEntry directoryEntry;
 
        public static TimeSpan SpnLookupTime
        { 
            get 
            {
                return spnLookupTime; 
            }
            set
            {
                if (value.Ticks < 0) 
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value.Ticks, 
                                                    SR.GetString(SR.ValueMustBeNonNegative))); 
                }
                spnLookupTime = value; 
            }
        }

        public SpnEndpointIdentity(string spnName) 
        {
            if (spnName == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("spnName"); 

            base.Initialize(Claim.CreateSpnClaim(spnName)); 
        }

        public SpnEndpointIdentity(Claim identity)
        { 
            if (identity == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("identity"); 
 
            // PreSharp Bug: Parameter 'identity.ResourceType' to this public method must be validated: A null-dereference can occur here.
            #pragma warning suppress 56506 // Claim.ClaimType will never return null 
            if (!identity.ClaimType.Equals(ClaimTypes.Spn))
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.UnrecognizedClaimTypeForIdentity, identity.ClaimType, ClaimTypes.Spn));

            base.Initialize(identity); 
        }
 
        internal override void WriteContentsTo(XmlDictionaryWriter writer) 
        {
            if (writer == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");

            writer.WriteElementString(XD.AddressingDictionary.Spn, XD.AddressingDictionary.IdentityExtensionNamespace, (string)this.IdentityClaim.Resource);
        } 

        internal SecurityIdentifier GetSpnSid() 
        { 
            DiagnosticUtility.DebugAssert(ClaimTypes.Spn.Equals(this.IdentityClaim.ClaimType) || ClaimTypes.Dns.Equals(this.IdentityClaim.ClaimType), "");
            if (!hasSpnSidBeenComputed) 
            {
                lock (thisLock)
                {
                    if (!hasSpnSidBeenComputed) 
                    {
                        string spn = null; 
                        try 
                        {
 
                            if (ClaimTypes.Dns.Equals(this.IdentityClaim.ClaimType))
                            {
                                spn = "host/" + (string)this.IdentityClaim.Resource;
                            } 
                            else
                            { 
                                spn = (string)this.IdentityClaim.Resource; 
                            }
                            // canonicalize SPN for use in LDAP filter following RFC 1960: 
                            if (spn != null)
                            {
                                spn = spn.Replace("*",@"\*").Replace("(",@"\(").Replace(")",@"\)");
                            } 

                            DirectoryEntry de = GetDirectoryEntry(); 
                            using (DirectorySearcher searcher = new DirectorySearcher(de)) 
                            {
                                searcher.CacheResults = true; 
                                searcher.ClientTimeout = SpnLookupTime;
                                searcher.Filter = "(&(objectCategory=Computer)(objectClass=computer)(servicePrincipalName=" + spn + "))";
                                searcher.PropertiesToLoad.Add("objectSid");
                                SearchResult result = searcher.FindOne(); 
                                if (result != null)
                                { 
                                    byte[] sidBinaryForm = (byte[])result.Properties["objectSid"][0]; 
                                    this.spnSid = new SecurityIdentifier(sidBinaryForm, 0);
                                } 
                                else
                                {
                                    SecurityTraceRecordHelper.TraceSpnToSidMappingFailure(spn, null);
                                } 
                            }
                        } 
#pragma warning suppress 56500 // covered by FxCOP 
                        catch (Exception e)
                        { 
                            // Always immediately rethrow fatal exceptions.
                            if (DiagnosticUtility.IsFatal(e)) throw;

                            if (e is NullReferenceException || e is SEHException) 
                                throw;
 
                            SecurityTraceRecordHelper.TraceSpnToSidMappingFailure(spn, e); 
                        }
                        finally 
                        {
                            hasSpnSidBeenComputed = true;
                        }
                    } 
                }
            } 
            return this.spnSid; 
        }
 
        static DirectoryEntry GetDirectoryEntry()
        {
            if (directoryEntry == null)
            { 
                lock (typeLock)
                { 
                    if (directoryEntry == null) 
                    {
                        DirectoryEntry tmp = new DirectoryEntry(@"LDAP://" + SecurityUtils.GetPrimaryDomain()); 
                        tmp.RefreshCache(new string[] { "name" });
                        System.Threading.Thread.MemoryBarrier();
                        directoryEntry = tmp;
                    } 
                }
            } 
            return directoryEntry; 
        }
    } 

}

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