StrongName.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Security / Policy / StrongName.cs / 1305376 / StrongName.cs

                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
// [....]
// 
 
//
// StrongName.cs 
//
// StrongName is an IIdentity representing strong names.
//
 
namespace System.Security.Policy {
    using System.IO; 
    using System.Reflection; 
    using System.Security.Util;
    using System.Security.Permissions; 
    using System.Diagnostics.Contracts;
    using CultureInfo = System.Globalization.CultureInfo;

    [Serializable] 
    [System.Runtime.InteropServices.ComVisible(true)]
    public sealed class StrongName : EvidenceBase, IIdentityPermissionFactory, IDelayEvaluatedEvidence 
    { 
        private StrongNamePublicKeyBlob m_publicKeyBlob;
        private String m_name; 
        private Version m_version;

        // Delay evaluated evidence is for policy resolution only, so it doesn't make sense to save that
        // state away and then try to evaluate the strong name later. 
        [NonSerialized]
        private RuntimeAssembly m_assembly = null; 
 
        [NonSerialized]
        private bool m_wasUsed = false; 

        internal StrongName() {}

        public StrongName( StrongNamePublicKeyBlob blob, String name, Version version ) : this(blob, name, version, null) 
        {
        } 
 
        internal StrongName(StrongNamePublicKeyBlob blob, String name, Version version, Assembly assembly)
        { 
            if (name == null)
                throw new ArgumentNullException("name");
            if (String.IsNullOrEmpty(name))
                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName")); 

            if (blob == null) 
                throw new ArgumentNullException("blob"); 

            if (version == null) 
                throw new ArgumentNullException("version");
            Contract.EndContractBlock();

            RuntimeAssembly rtAssembly = assembly as RuntimeAssembly; 
            if (assembly != null && rtAssembly == null)
                throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeAssembly"), "assembly"); 
 
            m_publicKeyBlob = blob;
            m_name = name; 
            m_version = version;
            m_assembly = rtAssembly;
        }
 
        public StrongNamePublicKeyBlob PublicKey
        { 
            get 
            {
                return m_publicKeyBlob; 
            }
        }

        public String Name 
        {
            get 
            { 
                return m_name;
            } 
        }

        public Version Version
        { 
            get
            { 
                return m_version; 
            }
        } 

        bool IDelayEvaluatedEvidence.IsVerified
        {
            [System.Security.SecurityCritical]  // auto-generated 
            get
            { 
#if FEATURE_CAS_POLICY 
                return m_assembly != null ? m_assembly.IsStrongNameVerified : true;
#else // !FEATURE_CAS_POLICY 
                return true;
#endif // FEATURE_CAS_POLICY
            }
        } 

        bool IDelayEvaluatedEvidence.WasUsed 
        { 
            get { return m_wasUsed; }
        } 

        void IDelayEvaluatedEvidence.MarkUsed()
        {
            m_wasUsed = true; 
        }
 
        internal static bool CompareNames( String asmName, String mcName ) 
        {
            if (mcName.Length > 0 && mcName[mcName.Length-1] == '*' && mcName.Length - 1 <= asmName.Length) 
                return String.Compare( mcName, 0, asmName, 0, mcName.Length - 1, StringComparison.OrdinalIgnoreCase) == 0;
            else
                return String.Compare( mcName, asmName, StringComparison.OrdinalIgnoreCase) == 0;
        } 

        public IPermission CreateIdentityPermission( Evidence evidence ) 
        { 
            return new StrongNameIdentityPermission( m_publicKeyBlob, m_name, m_version );
        } 

        public override EvidenceBase Clone()
        {
            return new StrongName(m_publicKeyBlob, m_name, m_version); 
        }
 
        public Object Copy() 
        {
            return Clone(); 
        }

#if FEATURE_CAS_POLICY
        internal SecurityElement ToXml() 
        {
            SecurityElement root = new SecurityElement( "StrongName" ); 
            root.AddAttribute( "version", "1" ); 

            if (m_publicKeyBlob != null) 
                root.AddAttribute( "Key", System.Security.Util.Hex.EncodeHexString( m_publicKeyBlob.PublicKey ) );

            if (m_name != null)
                root.AddAttribute( "Name", m_name ); 

            if (m_version != null) 
                root.AddAttribute( "Version", m_version.ToString() ); 

            return root; 
        }

        internal void FromXml (SecurityElement element)
        { 
            if (element == null)
                throw new ArgumentNullException("element"); 
            if (String.Compare(element.Tag, "StrongName", StringComparison.Ordinal) != 0) 
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidXML"));
            Contract.EndContractBlock(); 

            m_publicKeyBlob = null;
            m_version = null;
 
            string key = element.Attribute("Key");
            if (key != null) 
                m_publicKeyBlob = new StrongNamePublicKeyBlob(System.Security.Util.Hex.DecodeHexString(key)); 

            m_name = element.Attribute("Name"); 

            string version = element.Attribute("Version");
            if (version != null)
                m_version = new Version(version); 
        }
 
        public override String ToString() 
        {
            return ToXml().ToString(); 
        }
#endif // FEATURE_CAS_POLICY

        public override bool Equals( Object o ) 
        {
            StrongName that = (o as StrongName); 
            return (that != null) && 
                   Equals( this.m_publicKeyBlob, that.m_publicKeyBlob ) &&
                   Equals( this.m_name, that.m_name ) && 
                   Equals( this.m_version, that.m_version );
        }

        public override int GetHashCode() 
        {
            if (m_publicKeyBlob != null) 
            { 
                return m_publicKeyBlob.GetHashCode();
            } 
            else if (m_name != null || m_version != null)
            {
                return (m_name == null ? 0 : m_name.GetHashCode()) + (m_version == null ? 0 : m_version.GetHashCode());
            } 
            else
            { 
                return typeof( StrongName ).GetHashCode(); 
            }
        } 

        // INormalizeForIsolatedStorage is not implemented for startup perf
        // equivalent to INormalizeForIsolatedStorage.Normalize()
        internal Object Normalize() 
        {
            MemoryStream ms = new MemoryStream(); 
            BinaryWriter bw = new BinaryWriter(ms); 

            bw.Write(m_publicKeyBlob.PublicKey); 
            bw.Write(m_version.Major);
            bw.Write(m_name);

            ms.Position = 0; 
            return ms;
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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