The Labs \ Source Viewer \ SSCLI \ System.Security.Policy \ StrongNameMembershipCondition

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. // StrongNameMembershipCondition.cs
  16. //
  17. // Implementation of membership condition for zones
  18. //
  19. namespace System.Security.Policy
  20. {
  21.     using System.Text;
  22.     using System.Configuration.Assemblies;
  23.     using System;
  24.     using SecurityManager = System.Security.SecurityManager;
  25.     using StrongNamePublicKeyBlob = System.Security.Permissions.StrongNamePublicKeyBlob;
  26.     using PermissionSet = System.Security.PermissionSet;
  27.     using SecurityElement = System.Security.SecurityElement;
  28.     using System.Collections;
  29.     using System.Globalization;
  30.    
  31.    
  32.     [Serializable()]
  33.     [System.Runtime.InteropServices.ComVisible(true)]
  34.     public sealed class StrongNameMembershipCondition : IMembershipCondition, IConstantMembershipCondition
  35.     {
  36.         //------------------------------------------------------
  37.         //
  38.         // PRIVATE STATE DATA
  39.         //
  40.         //------------------------------------------------------
  41.        
  42.         private StrongNamePublicKeyBlob m_publicKeyBlob;
  43.         private string m_name;
  44.         private Version m_version;
  45.         private SecurityElement m_element;
  46.        
  47.         //------------------------------------------------------
  48.         //
  49.         // PUBLIC CONSTRUCTORS
  50.         //
  51.         //------------------------------------------------------
  52.        
  53.         internal StrongNameMembershipCondition()
  54.         {
  55.         }
  56.        
  57.         public StrongNameMembershipCondition(StrongNamePublicKeyBlob blob, string name, Version version)
  58.         {
  59.             if (blob == null)
  60.                 throw new ArgumentNullException("blob");
  61.            
  62.             if (name != null && name.Equals(""))
  63.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName"));
  64.            
  65.             m_publicKeyBlob = blob;
  66.             m_name = name;
  67.             m_version = version;
  68.         }
  69.        
  70.         //------------------------------------------------------
  71.         //
  72.         // PUBLIC ACCESSOR METHODS
  73.         //
  74.         //------------------------------------------------------
  75.        
  76.         public StrongNamePublicKeyBlob PublicKey {
  77.            
  78.            
  79.             get {
  80.                 if (m_publicKeyBlob == null && m_element != null)
  81.                     ParseKeyBlob();
  82.                
  83.                 return m_publicKeyBlob;
  84.             }
  85.             set {
  86.                 if (value == null)
  87.                     throw new ArgumentNullException("PublicKey");
  88.                 m_publicKeyBlob = value;
  89.             }
  90.         }
  91.        
  92.         public string Name {
  93.            
  94.            
  95.            
  96.            
  97.             get {
  98.                 if (m_name == null && m_element != null)
  99.                     ParseName();
  100.                
  101.                 return m_name;
  102.             }
  103.             set {
  104.                 if (value == null) {
  105.                     if (m_publicKeyBlob == null && m_element != null)
  106.                         ParseKeyBlob();
  107.                     if ((object)m_version == null && m_element != null)
  108.                         ParseVersion();
  109.                     m_element = null;
  110.                 }
  111.                 else if (value.Length == 0)
  112.                     throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"));
  113.                 m_name = value;
  114.             }
  115.         }
  116.        
  117.         public Version Version {
  118.            
  119.            
  120.            
  121.            
  122.             get {
  123.                 if ((object)m_version == null && m_element != null)
  124.                     ParseVersion();
  125.                
  126.                 return m_version;
  127.             }
  128.             set {
  129.                 if (value == null) {
  130.                     if (m_name == null && m_element != null)
  131.                         ParseName();
  132.                     if (m_publicKeyBlob == null && m_element != null)
  133.                         ParseKeyBlob();
  134.                     m_element = null;
  135.                 }
  136.                 m_version = value;
  137.             }
  138.         }
  139.        
  140.         //------------------------------------------------------
  141.         //
  142.         // IMEMBERSHIPCONDITION IMPLEMENTATION
  143.         //
  144.         //------------------------------------------------------
  145.        
  146.         public bool Check(Evidence evidence)
  147.         {
  148.             if (evidence == null)
  149.                 return false;
  150.            
  151.             IEnumerator enumerator = evidence.GetHostEnumerator();
  152.             while (enumerator.MoveNext()) {
  153.                 if (enumerator.Current is StrongName) {
  154.                     StrongName name = (StrongName)enumerator.Current;
  155.                    
  156.                     if ((this.PublicKey != null && this.PublicKey.Equals(name.PublicKey)) && (this.Name == null || (name.Name != null && StrongName.CompareNames(name.Name, this.Name))) && ((object)this.Version == null || ((object)name.Version != null && name.Version.CompareTo(this.Version) == 0))) {
  157.                         return true;
  158.                     }
  159.                 }
  160.             }
  161.             return false;
  162.         }
  163.        
  164.         public IMembershipCondition Copy()
  165.         {
  166.             return new StrongNameMembershipCondition(PublicKey, Name, Version);
  167.         }
  168.        
  169.         private const string s_tagName = "Name";
  170.         private const string s_tagVersion = "AssemblyVersion";
  171.         private const string s_tagPublicKeyBlob = "PublicKeyBlob";
  172.        
  173.         public SecurityElement ToXml()
  174.         {
  175.             return ToXml(null);
  176.         }
  177.        
  178.         public void FromXml(SecurityElement e)
  179.         {
  180.             FromXml(e, null);
  181.         }
  182.        
  183.         public SecurityElement ToXml(PolicyLevel level)
  184.         {
  185.             SecurityElement root = new SecurityElement("IMembershipCondition");
  186.             System.Security.Util.XMLUtil.AddClassAttribute(root, this.GetType(), "System.Security.Policy.StrongNameMembershipCondition");
  187.             // If you hit this assert then most likely you are trying to change the name of this class.
  188.             // This is ok as long as you change the hard coded string above and change the assert below.
  189.             BCLDebug.Assert(this.GetType().FullName.Equals("System.Security.Policy.StrongNameMembershipCondition"), "Class name changed!");
  190.            
  191.             root.AddAttribute("version", "1");
  192.            
  193.             if (PublicKey != null)
  194.                 root.AddAttribute(s_tagPublicKeyBlob, System.Security.Util.Hex.EncodeHexString(PublicKey.PublicKey));
  195.            
  196.             if (Name != null)
  197.                 root.AddAttribute(s_tagName, Name);
  198.            
  199.             if ((object)Version != null)
  200.                 root.AddAttribute(s_tagVersion, Version.ToString());
  201.            
  202.             return root;
  203.            
  204.         }
  205.        
  206.         public void FromXml(SecurityElement e, PolicyLevel level)
  207.         {
  208.             if (e == null)
  209.                 throw new ArgumentNullException("e");
  210.            
  211.             if (!e.Tag.Equals("IMembershipCondition")) {
  212.                 throw new ArgumentException(Environment.GetResourceString("Argument_MembershipConditionElement"));
  213.             }
  214.            
  215.             lock (this) {
  216.                 m_name = null;
  217.                 m_publicKeyBlob = null;
  218.                 m_version = null;
  219.                 m_element = e;
  220.             }
  221.         }
  222.        
  223.        
  224.         private void ParseName()
  225.         {
  226.             lock (this) {
  227.                 if (m_element == null)
  228.                     return;
  229.                
  230.                 string elSite = m_element.Attribute(s_tagName);
  231.                 m_name = elSite == null ? null : elSite;
  232.                
  233.                 if ((object)m_version != null && m_name != null && m_publicKeyBlob != null) {
  234.                     m_element = null;
  235.                 }
  236.             }
  237.         }
  238.        
  239.         private void ParseKeyBlob()
  240.         {
  241.             lock (this) {
  242.                 if (m_element == null)
  243.                     return;
  244.                
  245.                 string elBlob = m_element.Attribute(s_tagPublicKeyBlob);
  246.                 StrongNamePublicKeyBlob publicKeyBlob = new StrongNamePublicKeyBlob();
  247.                
  248.                 if (elBlob != null)
  249.                     publicKeyBlob.PublicKey = System.Security.Util.Hex.DecodeHexString(elBlob);
  250.                 else
  251.                     throw new ArgumentException(Environment.GetResourceString("Argument_BlobCannotBeNull"));
  252.                
  253.                 m_publicKeyBlob = publicKeyBlob;
  254.                
  255.                 if ((object)m_version != null && m_name != null && m_publicKeyBlob != null) {
  256.                     m_element = null;
  257.                 }
  258.             }
  259.         }
  260.        
  261.         private void ParseVersion()
  262.         {
  263.             lock (this) {
  264.                 if (m_element == null)
  265.                     return;
  266.                
  267.                 string elVersion = m_element.Attribute(s_tagVersion);
  268.                 m_version = elVersion == null ? null : new Version(elVersion);
  269.                
  270.                 if ((object)m_version != null && m_name != null && m_publicKeyBlob != null) {
  271.                     m_element = null;
  272.                 }
  273.             }
  274.         }
  275.        
  276.         public override string ToString()
  277.         {
  278.             string sName = "";
  279.             string sVersion = "";
  280.            
  281.             if (Name != null)
  282.                 sName = " " + String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("StrongName_Name"), Name);
  283.            
  284.             if ((object)Version != null)
  285.                 sVersion = " " + String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("StrongName_Version"), Version);
  286.            
  287.             return String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("StrongName_ToString"), System.Security.Util.Hex.EncodeHexString(PublicKey.PublicKey), sName, sVersion);
  288.         }
  289.        
  290.         public override bool Equals(object o)
  291.         {
  292.             StrongNameMembershipCondition that = (o as StrongNameMembershipCondition);
  293.            
  294.             if (that != null) {
  295.                 if (this.m_publicKeyBlob == null && this.m_element != null)
  296.                     this.ParseKeyBlob();
  297.                 if (that.m_publicKeyBlob == null && that.m_element != null)
  298.                     that.ParseKeyBlob();
  299.                
  300.                 if (Equals(this.m_publicKeyBlob, that.m_publicKeyBlob)) {
  301.                     if (this.m_name == null && this.m_element != null)
  302.                         this.ParseName();
  303.                     if (that.m_name == null && that.m_element != null)
  304.                         that.ParseName();
  305.                    
  306.                     if (Equals(this.m_name, that.m_name)) {
  307.                         if (this.m_version == null && this.m_element != null)
  308.                             this.ParseVersion();
  309.                         if (that.m_version == null && that.m_element != null)
  310.                             that.ParseVersion();
  311.                        
  312.                         if (Equals(this.m_version, that.m_version)) {
  313.                             return true;
  314.                         }
  315.                     }
  316.                 }
  317.             }
  318.             return false;
  319.         }
  320.        
  321.         public override int GetHashCode()
  322.         {
  323.             if (m_publicKeyBlob == null && m_element != null)
  324.                 ParseKeyBlob();
  325.            
  326.             if (m_publicKeyBlob != null) {
  327.                 return m_publicKeyBlob.GetHashCode();
  328.             }
  329.             else {
  330.                 if (m_name == null && m_element != null)
  331.                     ParseName();
  332.                 if (m_version == null && m_element != null)
  333.                     ParseVersion();
  334.                
  335.                 if (m_name != null || m_version != null) {
  336.                     return (m_name == null ? 0 : m_name.GetHashCode()) + (m_version == null ? 0 : m_version.GetHashCode());
  337.                 }
  338.                 else {
  339.                     return typeof(StrongNameMembershipCondition).GetHashCode();
  340.                 }
  341.             }
  342.         }
  343.     }
  344. }

Developer Fusion