The Labs \ Source Viewer \ SSCLI \ System.Security.Permissions \ StrongNameIdentityPermission

  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. // StrongNameIdentityPermission.cs
  16. //
  17. namespace System.Security.Permissions
  18. {
  19.     using System;
  20.     using SecurityElement = System.Security.SecurityElement;
  21.     using System.Security.Util;
  22.     using System.IO;
  23.     using String = System.String;
  24.     using Version = System.Version;
  25.     using System.Security.Policy;
  26.     using System.Collections;
  27.     using System.Globalization;
  28.    
  29.     // The only difference between this class and System.Security.Policy.StrongName is that this one
  30.     // allows m_name to be null. We should merge this class with System.Security.Policy.StrongName
  31.     [Serializable()]
  32.     internal sealed class StrongName2
  33.     {
  34.         public StrongNamePublicKeyBlob m_publicKeyBlob;
  35.         public string m_name;
  36.         public Version m_version;
  37.        
  38.         public StrongName2(StrongNamePublicKeyBlob publicKeyBlob, string name, Version version)
  39.         {
  40.             m_publicKeyBlob = publicKeyBlob;
  41.             m_name = name;
  42.             m_version = version;
  43.         }
  44.        
  45.         public StrongName2 Copy()
  46.         {
  47.             return new StrongName2(m_publicKeyBlob, m_name, m_version);
  48.         }
  49.        
  50.         public bool IsSubsetOf(StrongName2 target)
  51.         {
  52.             // This StrongName2 is a subset of the target if it's public key blob is null no matter what
  53.             if (this.m_publicKeyBlob == null)
  54.                 return true;
  55.            
  56.             // Subsets are always false if the public key blobs do not match
  57.             if (!this.m_publicKeyBlob.Equals(target.m_publicKeyBlob))
  58.                 return false;
  59.            
  60.             // We use null in strings to represent the "Anything" state.
  61.             // Therefore, the logic to detect an individual subset is:
  62.             //
  63.             // 1. If the this string is null ("Anything" is a subset of any other).
  64.             // 2. If the this string and target string are the same (equality is sufficient for a subset).
  65.             //
  66.             // The logic is reversed here to discover things that are not subsets.
  67.             if (this.m_name != null) {
  68.                 if (target.m_name == null || !System.Security.Policy.StrongName.CompareNames(target.m_name, this.m_name))
  69.                     return false;
  70.             }
  71.            
  72.             if ((object)this.m_version != null) {
  73.                 if ((object)target.m_version == null || target.m_version.CompareTo(this.m_version) != 0) {
  74.                     return false;
  75.                 }
  76.             }
  77.            
  78.             return true;
  79.         }
  80.        
  81.         public StrongName2 Intersect(StrongName2 target)
  82.         {
  83.             if (target.IsSubsetOf(this))
  84.                 return target.Copy();
  85.             else if (this.IsSubsetOf(target))
  86.                 return this.Copy();
  87.             else
  88.                 return null;
  89.         }
  90.        
  91.         public bool Equals(StrongName2 target)
  92.         {
  93.             if (!target.IsSubsetOf(this))
  94.                 return false;
  95.             if (!this.IsSubsetOf(target))
  96.                 return false;
  97.             return true;
  98.         }
  99.     }
  100.    
  101.    
  102.    
  103.     [System.Runtime.InteropServices.ComVisible(true)]
  104.     [Serializable()]
  105.     public sealed class StrongNameIdentityPermission : CodeAccessPermission, IBuiltInPermission
  106.     {
  107.         //------------------------------------------------------
  108.         //
  109.         // PRIVATE STATE DATA
  110.         //
  111.         //------------------------------------------------------
  112.        
  113.         private bool m_unrestricted;
  114.         private StrongName2[] m_strongNames;
  115.        
  116.         //------------------------------------------------------
  117.         //
  118.         // PUBLIC CONSTRUCTORS
  119.         //
  120.         //------------------------------------------------------
  121.        
  122.        
  123.         public StrongNameIdentityPermission(PermissionState state)
  124.         {
  125.             if (state == PermissionState.Unrestricted) {
  126.                 if (CodeAccessSecurityEngine.DoesFullTrustMeanFullTrust())
  127.                     m_unrestricted = true;
  128.                 else
  129.                     throw new ArgumentException(Environment.GetResourceString("Argument_UnrestrictedIdentityPermission"));
  130.             }
  131.             else if (state == PermissionState.None) {
  132.                 m_unrestricted = false;
  133.             }
  134.             else {
  135.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  136.             }
  137.         }
  138.        
  139.         public StrongNameIdentityPermission(StrongNamePublicKeyBlob blob, string name, Version version)
  140.         {
  141.             if (blob == null)
  142.                 throw new ArgumentNullException("blob");
  143.             if (name != null && name.Equals(""))
  144.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName"));
  145.             m_unrestricted = false;
  146.             m_strongNames = new StrongName2[1];
  147.             m_strongNames[0] = new StrongName2(blob, name, version);
  148.         }
  149.        
  150.        
  151.         //------------------------------------------------------
  152.         //
  153.         // PUBLIC ACCESSOR METHODS
  154.         //
  155.         //------------------------------------------------------
  156.        
  157.         public StrongNamePublicKeyBlob PublicKey {
  158.            
  159.             get {
  160.                 if (m_strongNames == null || m_strongNames.Length == 0)
  161.                     return null;
  162.                 if (m_strongNames.Length > 1)
  163.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
  164.                 return m_strongNames[0].m_publicKeyBlob;
  165.             }
  166.             set {
  167.                 if (value == null)
  168.                     throw new ArgumentNullException("PublicKey");
  169.                 m_unrestricted = false;
  170.                 if (m_strongNames != null && m_strongNames.Length == 1)
  171.                     m_strongNames[0].m_publicKeyBlob = value;
  172.                 else {
  173.                     m_strongNames = new StrongName2[1];
  174.                     m_strongNames[0] = new StrongName2(value, "", new Version());
  175.                 }
  176.             }
  177.         }
  178.        
  179.         public string Name {
  180.            
  181.             get {
  182.                 if (m_strongNames == null || m_strongNames.Length == 0)
  183.                     return "";
  184.                 if (m_strongNames.Length > 1)
  185.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
  186.                 return m_strongNames[0].m_name;
  187.             }
  188.             set {
  189.                 if (value != null && value.Length == 0)
  190.                     throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"));
  191.                 m_unrestricted = false;
  192.                 if (m_strongNames != null && m_strongNames.Length == 1)
  193.                     m_strongNames[0].m_name = value;
  194.                 else {
  195.                     m_strongNames = new StrongName2[1];
  196.                     m_strongNames[0] = new StrongName2(null, value, new Version());
  197.                 }
  198.             }
  199.         }
  200.        
  201.         public Version Version {
  202.            
  203.             get {
  204.                 if (m_strongNames == null || m_strongNames.Length == 0)
  205.                     return new Version();
  206.                 if (m_strongNames.Length > 1)
  207.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
  208.                 return m_strongNames[0].m_version;
  209.             }
  210.             set {
  211.                 m_unrestricted = false;
  212.                 if (m_strongNames != null && m_strongNames.Length == 1)
  213.                     m_strongNames[0].m_version = value;
  214.                 else {
  215.                     m_strongNames = new StrongName2[1];
  216.                     m_strongNames[0] = new StrongName2(null, "", value);
  217.                 }
  218.             }
  219.         }
  220.        
  221.         //------------------------------------------------------
  222.         //
  223.         // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
  224.         //
  225.         //------------------------------------------------------
  226.        
  227.         //------------------------------------------------------
  228.         //
  229.         // CODEACCESSPERMISSION IMPLEMENTATION
  230.         //
  231.         //------------------------------------------------------
  232.        
  233.         //------------------------------------------------------
  234.         //
  235.         // IPERMISSION IMPLEMENTATION
  236.         //
  237.         //------------------------------------------------------
  238.        
  239.        
  240.         public override IPermission Copy()
  241.         {
  242.             StrongNameIdentityPermission perm = new StrongNameIdentityPermission(PermissionState.None);
  243.             perm.m_unrestricted = this.m_unrestricted;
  244.             if (this.m_strongNames != null) {
  245.                 perm.m_strongNames = new StrongName2[this.m_strongNames.Length];
  246.                 int n;
  247.                 for (n = 0; n < this.m_strongNames.Length; n++)
  248.                     perm.m_strongNames[n] = this.m_strongNames[n].Copy();
  249.             }
  250.             return perm;
  251.         }
  252.        
  253.         public override bool IsSubsetOf(IPermission target)
  254.         {
  255.             if (target == null) {
  256.                 if (m_unrestricted)
  257.                     return false;
  258.                 if (m_strongNames == null)
  259.                     return true;
  260.                 if (m_strongNames.Length == 0)
  261.                     return true;
  262.                 return false;
  263.             }
  264.             StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
  265.             if (that == null)
  266.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  267.             if (that.m_unrestricted)
  268.                 return true;
  269.             if (m_unrestricted)
  270.                 return false;
  271.             if (this.m_strongNames != null) {
  272.                 foreach (StrongName2 snThis in m_strongNames) {
  273.                     bool bOK = false;
  274.                     if (that.m_strongNames != null) {
  275.                         foreach (StrongName2 snThat in that.m_strongNames) {
  276.                             if (snThis.IsSubsetOf(snThat)) {
  277.                                 bOK = true;
  278.                                 break;
  279.                             }
  280.                         }
  281.                     }
  282.                     if (!bOK)
  283.                         return false;
  284.                 }
  285.             }
  286.             return true;
  287.         }
  288.        
  289.        
  290.        
  291.         public override IPermission Intersect(IPermission target)
  292.         {
  293.             if (target == null)
  294.                 return null;
  295.             StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
  296.             if (that == null)
  297.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  298.             if (this.m_unrestricted && that.m_unrestricted) {
  299.                 StrongNameIdentityPermission res = new StrongNameIdentityPermission(PermissionState.None);
  300.                 res.m_unrestricted = true;
  301.                 return res;
  302.             }
  303.             if (this.m_unrestricted)
  304.                 return that.Copy();
  305.             if (that.m_unrestricted)
  306.                 return this.Copy();
  307.             if (this.m_strongNames == null || that.m_strongNames == null || this.m_strongNames.Length == 0 || that.m_strongNames.Length == 0)
  308.                 return null;
  309.             ArrayList alStrongNames = new ArrayList();
  310.             foreach (StrongName2 snThis in this.m_strongNames) {
  311.                 foreach (StrongName2 snThat in that.m_strongNames) {
  312.                     StrongName2 snInt = (StrongName2)snThis.Intersect(snThat);
  313.                     if (snInt != null)
  314.                         alStrongNames.Add(snInt);
  315.                 }
  316.             }
  317.             if (alStrongNames.Count == 0)
  318.                 return null;
  319.             StrongNameIdentityPermission result = new StrongNameIdentityPermission(PermissionState.None);
  320.             result.m_strongNames = (StrongName2[])alStrongNames.ToArray(typeof(StrongName2));
  321.             return result;
  322.         }
  323.        
  324.         public override IPermission Union(IPermission target)
  325.         {
  326.             if (target == null) {
  327.                 if ((this.m_strongNames == null || this.m_strongNames.Length == 0) && !this.m_unrestricted)
  328.                     return null;
  329.                 return this.Copy();
  330.             }
  331.             StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
  332.             if (that == null)
  333.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  334.             if (this.m_unrestricted || that.m_unrestricted) {
  335.                 StrongNameIdentityPermission res = new StrongNameIdentityPermission(PermissionState.None);
  336.                 res.m_unrestricted = true;
  337.                 return res;
  338.             }
  339.             if (this.m_strongNames == null || this.m_strongNames.Length == 0) {
  340.                 if (that.m_strongNames == null || that.m_strongNames.Length == 0)
  341.                     return null;
  342.                 return that.Copy();
  343.             }
  344.             if (that.m_strongNames == null || that.m_strongNames.Length == 0)
  345.                 return this.Copy();
  346.             ArrayList alStrongNames = new ArrayList();
  347.             foreach (StrongName2 snThis in this.m_strongNames)
  348.                 alStrongNames.Add(snThis);
  349.             foreach (StrongName2 snThat in that.m_strongNames) {
  350.                 bool bDupe = false;
  351.                 foreach (StrongName2 sn in alStrongNames) {
  352.                     if (snThat.Equals(sn)) {
  353.                         bDupe = true;
  354.                         break;
  355.                     }
  356.                 }
  357.                 if (!bDupe)
  358.                     alStrongNames.Add(snThat);
  359.             }
  360.             StrongNameIdentityPermission result = new StrongNameIdentityPermission(PermissionState.None);
  361.             result.m_strongNames = (StrongName2[])alStrongNames.ToArray(typeof(StrongName2));
  362.             return result;
  363.         }
  364.        
  365.         public override void FromXml(SecurityElement e)
  366.         {
  367.             m_unrestricted = false;
  368.             m_strongNames = null;
  369.             CodeAccessPermission.ValidateElement(e, this);
  370.             string unr = e.Attribute("Unrestricted");
  371.             if (unr != null && String.Compare(unr, "true", StringComparison.OrdinalIgnoreCase) == 0) {
  372.                 m_unrestricted = true;
  373.                 return;
  374.             }
  375.             string elBlob = e.Attribute("PublicKeyBlob");
  376.             string elName = e.Attribute("Name");
  377.             string elVersion = e.Attribute("AssemblyVersion");
  378.             StrongName2 sn;
  379.             ArrayList al = new ArrayList();
  380.             if (elBlob != null || elName != null || elVersion != null) {
  381.                 sn = new StrongName2((elBlob == null ? null : new StrongNamePublicKeyBlob(elBlob)), elName, (elVersion == null ? null : new Version(elVersion)));
  382.                 al.Add(sn);
  383.             }
  384.             ArrayList alChildren = e.Children;
  385.             if (alChildren != null) {
  386.                 foreach (SecurityElement child in alChildren) {
  387.                     elBlob = child.Attribute("PublicKeyBlob");
  388.                     elName = child.Attribute("Name");
  389.                     elVersion = child.Attribute("AssemblyVersion");
  390.                     if (elBlob != null || elName != null || elVersion != null) {
  391.                         sn = new StrongName2((elBlob == null ? null : new StrongNamePublicKeyBlob(elBlob)), elName, (elVersion == null ? null : new Version(elVersion)));
  392.                         al.Add(sn);
  393.                     }
  394.                 }
  395.             }
  396.             if (al.Count != 0)
  397.                 m_strongNames = (StrongName2[])al.ToArray(typeof(StrongName2));
  398.         }
  399.        
  400.         public override SecurityElement ToXml()
  401.         {
  402.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.StrongNameIdentityPermission");
  403.             if (m_unrestricted)
  404.                 esd.AddAttribute("Unrestricted", "true");
  405.             else if (m_strongNames != null) {
  406.                 if (m_strongNames.Length == 1) {
  407.                     if (m_strongNames[0].m_publicKeyBlob != null)
  408.                         esd.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(m_strongNames[0].m_publicKeyBlob.PublicKey));
  409.                     if (m_strongNames[0].m_name != null)
  410.                         esd.AddAttribute("Name", m_strongNames[0].m_name);
  411.                     if ((object)m_strongNames[0].m_version != null)
  412.                         esd.AddAttribute("AssemblyVersion", m_strongNames[0].m_version.ToString());
  413.                 }
  414.                 else {
  415.                     int n;
  416.                     for (n = 0; n < m_strongNames.Length; n++) {
  417.                         SecurityElement child = new SecurityElement("StrongName");
  418.                         if (m_strongNames[n].m_publicKeyBlob != null)
  419.                             child.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(m_strongNames[n].m_publicKeyBlob.PublicKey));
  420.                         if (m_strongNames[n].m_name != null)
  421.                             child.AddAttribute("Name", m_strongNames[n].m_name);
  422.                         if ((object)m_strongNames[n].m_version != null)
  423.                             child.AddAttribute("AssemblyVersion", m_strongNames[n].m_version.ToString());
  424.                         esd.AddChild(child);
  425.                     }
  426.                 }
  427.             }
  428.             return esd;
  429.         }
  430.        
  431.         /// <internalonly/>
  432.         int IBuiltInPermission.GetTokenIndex()
  433.         {
  434.             return StrongNameIdentityPermission.GetTokenIndex();
  435.         }
  436.        
  437.         static internal int GetTokenIndex()
  438.         {
  439.             return BuiltInPermissionIndex.StrongNameIdentityPermissionIndex;
  440.         }
  441.        
  442.     }
  443. }

Developer Fusion