summaryrefslogtreecommitdiff
path: root/src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs
diff options
context:
space:
mode:
Diffstat (limited to 'src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs')
-rw-r--r--src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs487
1 files changed, 487 insertions, 0 deletions
diff --git a/src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs b/src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs
new file mode 100644
index 0000000000..5f5de0ef80
--- /dev/null
+++ b/src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs
@@ -0,0 +1,487 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Security.Permissions
+{
+ using System;
+#if FEATURE_CAS_POLICY
+ using SecurityElement = System.Security.SecurityElement;
+#endif // FEATURE_CAS_POLICY
+ using System.Security.Util;
+ using System.IO;
+ using String = System.String;
+ using Version = System.Version;
+ using System.Security.Policy;
+ using System.Collections;
+ using System.Collections.Generic;
+ using System.Globalization;
+ using System.Diagnostics.Contracts;
+
+ // The only difference between this class and System.Security.Policy.StrongName is that this one
+ // allows m_name to be null. We should merge this class with System.Security.Policy.StrongName
+ [Serializable]
+ sealed internal class StrongName2
+ {
+ public StrongNamePublicKeyBlob m_publicKeyBlob;
+ public String m_name;
+ public Version m_version;
+
+ public StrongName2(StrongNamePublicKeyBlob publicKeyBlob, String name, Version version)
+ {
+ m_publicKeyBlob = publicKeyBlob;
+ m_name = name;
+ m_version = version;
+ }
+
+ public StrongName2 Copy()
+ {
+ return new StrongName2(m_publicKeyBlob, m_name, m_version);
+ }
+
+ public bool IsSubsetOf(StrongName2 target)
+ {
+ // This StrongName2 is a subset of the target if it's public key blob is null no matter what
+ if (this.m_publicKeyBlob == null)
+ return true;
+
+ // Subsets are always false if the public key blobs do not match
+ if (!this.m_publicKeyBlob.Equals( target.m_publicKeyBlob ))
+ return false;
+
+ // We use null in strings to represent the "Anything" state.
+ // Therefore, the logic to detect an individual subset is:
+ //
+ // 1. If the this string is null ("Anything" is a subset of any other).
+ // 2. If the this string and target string are the same (equality is sufficient for a subset).
+ //
+ // The logic is reversed here to discover things that are not subsets.
+ if (this.m_name != null)
+ {
+ if (target.m_name == null || !System.Security.Policy.StrongName.CompareNames( target.m_name, this.m_name ))
+ return false;
+ }
+
+ if ((Object) this.m_version != null)
+ {
+ if ((Object) target.m_version == null ||
+ target.m_version.CompareTo( this.m_version ) != 0)
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public StrongName2 Intersect(StrongName2 target)
+ {
+ if (target.IsSubsetOf( this ))
+ return target.Copy();
+ else if (this.IsSubsetOf( target ))
+ return this.Copy();
+ else
+ return null;
+ }
+
+ public bool Equals(StrongName2 target)
+ {
+ if (!target.IsSubsetOf(this))
+ return false;
+ if (!this.IsSubsetOf(target))
+ return false;
+ return true;
+ }
+ }
+
+
+
+[System.Runtime.InteropServices.ComVisible(true)]
+ [Serializable]
+ sealed public class StrongNameIdentityPermission : CodeAccessPermission, IBuiltInPermission
+ {
+ //------------------------------------------------------
+ //
+ // PRIVATE STATE DATA
+ //
+ //------------------------------------------------------
+
+ private bool m_unrestricted;
+ private StrongName2[] m_strongNames;
+
+ //------------------------------------------------------
+ //
+ // PUBLIC CONSTRUCTORS
+ //
+ //------------------------------------------------------
+
+
+ public StrongNameIdentityPermission(PermissionState state)
+ {
+ if (state == PermissionState.Unrestricted)
+ {
+ m_unrestricted = true;
+ }
+ else if (state == PermissionState.None)
+ {
+ m_unrestricted = false;
+ }
+ else
+ {
+ throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
+ }
+ }
+
+ public StrongNameIdentityPermission( StrongNamePublicKeyBlob blob, String name, Version version )
+ {
+ if (blob == null)
+ throw new ArgumentNullException( "blob" );
+ if (name != null && name.Equals( "" ))
+ throw new ArgumentException( Environment.GetResourceString( "Argument_EmptyStrongName" ) );
+ Contract.EndContractBlock();
+ m_unrestricted = false;
+ m_strongNames = new StrongName2[1];
+ m_strongNames[0] = new StrongName2(blob, name, version);
+ }
+
+
+ //------------------------------------------------------
+ //
+ // PUBLIC ACCESSOR METHODS
+ //
+ //------------------------------------------------------
+
+ public StrongNamePublicKeyBlob PublicKey
+ {
+ set
+ {
+ if (value == null)
+ throw new ArgumentNullException( "PublicKey" );
+ Contract.EndContractBlock();
+ m_unrestricted = false;
+ if(m_strongNames != null && m_strongNames.Length == 1)
+ m_strongNames[0].m_publicKeyBlob = value;
+ else
+ {
+ m_strongNames = new StrongName2[1];
+ m_strongNames[0] = new StrongName2(value, "", new Version());
+ }
+ }
+
+ get
+ {
+ if(m_strongNames == null || m_strongNames.Length == 0)
+ return null;
+ if(m_strongNames.Length > 1)
+ throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
+ return m_strongNames[0].m_publicKeyBlob;
+ }
+ }
+
+ public String Name
+ {
+ set
+ {
+ if (value != null && value.Length == 0)
+ throw new ArgumentException( Environment.GetResourceString("Argument_EmptyName" ));
+ Contract.EndContractBlock();
+ m_unrestricted = false;
+ if(m_strongNames != null && m_strongNames.Length == 1)
+ m_strongNames[0].m_name = value;
+ else
+ {
+ m_strongNames = new StrongName2[1];
+ m_strongNames[0] = new StrongName2(null, value, new Version());
+ }
+ }
+
+ get
+ {
+ if(m_strongNames == null || m_strongNames.Length == 0)
+ return "";
+ if(m_strongNames.Length > 1)
+ throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
+ return m_strongNames[0].m_name;
+ }
+ }
+
+ public Version Version
+ {
+ set
+ {
+ m_unrestricted = false;
+ if(m_strongNames != null && m_strongNames.Length == 1)
+ m_strongNames[0].m_version = value;
+ else
+ {
+ m_strongNames = new StrongName2[1];
+ m_strongNames[0] = new StrongName2(null, "", value);
+ }
+ }
+
+ get
+ {
+ if(m_strongNames == null || m_strongNames.Length == 0)
+ return new Version();
+ if(m_strongNames.Length > 1)
+ throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
+ return m_strongNames[0].m_version;
+ }
+ }
+
+ //------------------------------------------------------
+ //
+ // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
+ //
+ //------------------------------------------------------
+
+ //------------------------------------------------------
+ //
+ // CODEACCESSPERMISSION IMPLEMENTATION
+ //
+ //------------------------------------------------------
+
+ //------------------------------------------------------
+ //
+ // IPERMISSION IMPLEMENTATION
+ //
+ //------------------------------------------------------
+
+
+ public override IPermission Copy()
+ {
+ StrongNameIdentityPermission perm = new StrongNameIdentityPermission(PermissionState.None);
+ perm.m_unrestricted = this.m_unrestricted;
+ if(this.m_strongNames != null)
+ {
+ perm.m_strongNames = new StrongName2[this.m_strongNames.Length];
+ int n;
+ for(n = 0; n < this.m_strongNames.Length; n++)
+ perm.m_strongNames[n] = this.m_strongNames[n].Copy();
+ }
+ return perm;
+ }
+
+ public override bool IsSubsetOf(IPermission target)
+ {
+ if (target == null)
+ {
+ if(m_unrestricted)
+ return false;
+ if(m_strongNames == null)
+ return true;
+ if(m_strongNames.Length == 0)
+ return true;
+ return false;
+ }
+ StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
+ if(that == null)
+ throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
+ if(that.m_unrestricted)
+ return true;
+ if(m_unrestricted)
+ return false;
+ if(this.m_strongNames != null)
+ {
+ foreach(StrongName2 snThis in m_strongNames)
+ {
+ bool bOK = false;
+ if(that.m_strongNames != null)
+ {
+ foreach(StrongName2 snThat in that.m_strongNames)
+ {
+ if(snThis.IsSubsetOf(snThat))
+ {
+ bOK = true;
+ break;
+ }
+ }
+ }
+ if(!bOK)
+ return false;
+ }
+ }
+ return true;
+ }
+
+
+
+ public override IPermission Intersect(IPermission target)
+ {
+ if (target == null)
+ return null;
+ StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
+ if(that == null)
+ throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
+ if(this.m_unrestricted && that.m_unrestricted)
+ {
+ StrongNameIdentityPermission res = new StrongNameIdentityPermission(PermissionState.None);
+ res.m_unrestricted = true;
+ return res;
+ }
+ if(this.m_unrestricted)
+ return that.Copy();
+ if(that.m_unrestricted)
+ return this.Copy();
+ if(this.m_strongNames == null || that.m_strongNames == null || this.m_strongNames.Length == 0 || that.m_strongNames.Length == 0)
+ return null;
+ List<StrongName2> alStrongNames = new List<StrongName2>();
+ foreach(StrongName2 snThis in this.m_strongNames)
+ {
+ foreach(StrongName2 snThat in that.m_strongNames)
+ {
+ StrongName2 snInt = (StrongName2)snThis.Intersect(snThat);
+ if(snInt != null)
+ alStrongNames.Add(snInt);
+ }
+ }
+ if(alStrongNames.Count == 0)
+ return null;
+ StrongNameIdentityPermission result = new StrongNameIdentityPermission(PermissionState.None);
+ result.m_strongNames = alStrongNames.ToArray();
+ return result;
+ }
+
+ public override IPermission Union(IPermission target)
+ {
+ if (target == null)
+ {
+ if((this.m_strongNames == null || this.m_strongNames.Length == 0) && !this.m_unrestricted)
+ return null;
+ return this.Copy();
+ }
+ StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
+ if(that == null)
+ throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
+ if(this.m_unrestricted || that.m_unrestricted)
+ {
+ StrongNameIdentityPermission res = new StrongNameIdentityPermission(PermissionState.None);
+ res.m_unrestricted = true;
+ return res;
+ }
+ if (this.m_strongNames == null || this.m_strongNames.Length == 0)
+ {
+ if(that.m_strongNames == null || that.m_strongNames.Length == 0)
+ return null;
+ return that.Copy();
+ }
+ if(that.m_strongNames == null || that.m_strongNames.Length == 0)
+ return this.Copy();
+ List<StrongName2> alStrongNames = new List<StrongName2>();
+ foreach(StrongName2 snThis in this.m_strongNames)
+ alStrongNames.Add(snThis);
+ foreach(StrongName2 snThat in that.m_strongNames)
+ {
+ bool bDupe = false;
+ foreach(StrongName2 sn in alStrongNames)
+ {
+ if(snThat.Equals(sn))
+ {
+ bDupe = true;
+ break;
+ }
+ }
+ if(!bDupe)
+ alStrongNames.Add(snThat);
+ }
+ StrongNameIdentityPermission result = new StrongNameIdentityPermission(PermissionState.None);
+ result.m_strongNames = alStrongNames.ToArray();
+ return result;
+ }
+
+#if FEATURE_CAS_POLICY
+ public override void FromXml(SecurityElement e)
+ {
+ m_unrestricted = false;
+ m_strongNames = null;
+ CodeAccessPermission.ValidateElement( e, this );
+ String unr = e.Attribute( "Unrestricted" );
+ if(unr != null && String.Compare(unr, "true", StringComparison.OrdinalIgnoreCase) == 0)
+ {
+ m_unrestricted = true;
+ return;
+ }
+ String elBlob = e.Attribute("PublicKeyBlob");
+ String elName = e.Attribute("Name");
+ String elVersion = e.Attribute("AssemblyVersion");
+ StrongName2 sn;
+ List<StrongName2> al = new List<StrongName2>();
+ if(elBlob != null || elName != null || elVersion != null)
+ {
+ sn = new StrongName2(
+ (elBlob == null ? null : new StrongNamePublicKeyBlob(elBlob)),
+ elName,
+ (elVersion == null ? null : new Version(elVersion)));
+ al.Add(sn);
+ }
+ ArrayList alChildren = e.Children;
+ if(alChildren != null)
+ {
+ foreach(SecurityElement child in alChildren)
+ {
+ elBlob = child.Attribute("PublicKeyBlob");
+ elName = child.Attribute("Name");
+ elVersion = child.Attribute("AssemblyVersion");
+ if(elBlob != null || elName != null || elVersion != null)
+ {
+ sn = new StrongName2(
+ (elBlob == null ? null : new StrongNamePublicKeyBlob(elBlob)),
+ elName,
+ (elVersion == null ? null : new Version(elVersion)));
+ al.Add(sn);
+ }
+ }
+ }
+ if(al.Count != 0)
+ m_strongNames = al.ToArray();
+ }
+
+ public override SecurityElement ToXml()
+ {
+ SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, "System.Security.Permissions.StrongNameIdentityPermission" );
+ if (m_unrestricted)
+ esd.AddAttribute( "Unrestricted", "true" );
+ else if (m_strongNames != null)
+ {
+ if (m_strongNames.Length == 1)
+ {
+ if (m_strongNames[0].m_publicKeyBlob != null)
+ esd.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(m_strongNames[0].m_publicKeyBlob.PublicKey));
+ if (m_strongNames[0].m_name != null)
+ esd.AddAttribute("Name", m_strongNames[0].m_name);
+ if ((Object)m_strongNames[0].m_version != null)
+ esd.AddAttribute("AssemblyVersion", m_strongNames[0].m_version.ToString());
+ }
+ else
+ {
+ int n;
+ for(n = 0; n < m_strongNames.Length; n++)
+ {
+ SecurityElement child = new SecurityElement("StrongName");
+ if (m_strongNames[n].m_publicKeyBlob != null)
+ child.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(m_strongNames[n].m_publicKeyBlob.PublicKey));
+ if (m_strongNames[n].m_name != null)
+ child.AddAttribute("Name", m_strongNames[n].m_name);
+ if ((Object)m_strongNames[n].m_version != null)
+ child.AddAttribute("AssemblyVersion", m_strongNames[n].m_version.ToString());
+ esd.AddChild(child);
+ }
+ }
+ }
+ return esd;
+ }
+#endif // FEATURE_CAS_POLICY
+
+ /// <internalonly/>
+ int IBuiltInPermission.GetTokenIndex()
+ {
+ return StrongNameIdentityPermission.GetTokenIndex();
+ }
+
+ internal static int GetTokenIndex()
+ {
+ return BuiltInPermissionIndex.StrongNameIdentityPermissionIndex;
+ }
+
+ }
+}