diff options
Diffstat (limited to 'src/mscorlib/src/System/Security/Policy/StrongName.cs')
| -rw-r--r-- | src/mscorlib/src/System/Security/Policy/StrongName.cs | 221 |
1 files changed, 221 insertions, 0 deletions
diff --git a/src/mscorlib/src/System/Security/Policy/StrongName.cs b/src/mscorlib/src/System/Security/Policy/StrongName.cs new file mode 100644 index 0000000000..6e2d572e32 --- /dev/null +++ b/src/mscorlib/src/System/Security/Policy/StrongName.cs @@ -0,0 +1,221 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +// + +// +// +// 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; + } + } +} |