We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

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

SSCLI
  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. // ==--==
  16. //
  17. // StrongName.cs
  18. //
  19. // StrongName is an IIdentity representing strong names.
  20. //
  22. namespace System.Security.Policy
  23. {
  24.     using System.IO;
  25.     using System.Security.Util;
  26.     using System.Security.Permissions;
  27.     using CultureInfo = System.Globalization.CultureInfo;
  28.    
  29.     [Serializable()]
  30.     [System.Runtime.InteropServices.ComVisible(true)]
  31.     public sealed class StrongName : IIdentityPermissionFactory, IBuiltInEvidence
  32.     {
  33.         private StrongNamePublicKeyBlob m_publicKeyBlob;
  34.         private string m_name;
  35.         private Version m_version;
  36.        
  37.         internal StrongName()
  38.         {
  39.         }
  40.        
  41.         public StrongName(StrongNamePublicKeyBlob blob, string name, Version version)
  42.         {
  43.             if (name == null)
  44.                 throw new ArgumentNullException("name");
  45.             if (name.Equals(""))
  46.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName"));
  47.            
  48.             if (blob == null)
  49.                 throw new ArgumentNullException("blob");
  50.            
  51.             if (version == null)
  52.                 throw new ArgumentNullException("version");
  53.            
  54.             m_publicKeyBlob = blob;
  55.             m_name = name;
  56.             m_version = version;
  57.         }
  58.        
  59.         internal StrongName(StrongNamePublicKeyBlob blob, string name, Version version, bool trash)
  60.         {
  61.             m_publicKeyBlob = blob;
  62.             m_name = name;
  63.             m_version = version;
  64.         }
  65.        
  66.         public StrongNamePublicKeyBlob PublicKey {
  67.             get { return m_publicKeyBlob; }
  68.         }
  69.        
  70.         public string Name {
  71.             get { return m_name; }
  72.         }
  73.        
  74.         public Version Version {
  75.             get { return m_version; }
  76.         }
  77.        
  78.         static internal bool CompareNames(string asmName, string mcName)
  79.         {
  80.             if (mcName.Length > 0 && mcName[mcName.Length - 1] == '*' && mcName.Length - 1 <= asmName.Length)
  81.                 return String.Compare(mcName, 0, asmName, 0, mcName.Length - 1, StringComparison.OrdinalIgnoreCase) == 0;
  82.             else
  83.                 return String.Compare(mcName, asmName, StringComparison.OrdinalIgnoreCase) == 0;
  84.         }
  85.        
  86.         public IPermission CreateIdentityPermission(Evidence evidence)
  87.         {
  88.             return new StrongNameIdentityPermission(m_publicKeyBlob, m_name, m_version);
  89.         }
  90.        
  91.         public object Copy()
  92.         {
  93.             return new StrongName(m_publicKeyBlob, m_name, m_version);
  94.         }
  95.        
  96.         internal SecurityElement ToXml()
  97.         {
  98.             SecurityElement root = new SecurityElement("StrongName");
  99.             root.AddAttribute("version", "1");
  100.            
  101.             if (m_publicKeyBlob != null)
  102.                 root.AddAttribute("Key", System.Security.Util.Hex.EncodeHexString(m_publicKeyBlob.PublicKey));
  103.            
  104.             if (m_name != null)
  105.                 root.AddAttribute("Name", m_name);
  106.            
  107.             if (m_version != null)
  108.                 root.AddAttribute("Version", m_version.ToString());
  109.            
  110.             return root;
  111.         }
  112.        
  113.         internal void FromXml(SecurityElement element)
  114.         {
  115.             if (element == null)
  116.                 throw new ArgumentNullException("element");
  117.             if (String.Compare(element.Tag, "StrongName", StringComparison.Ordinal) != 0)
  118.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidXML"));
  119.            
  120.             m_publicKeyBlob = null;
  121.             m_version = null;
  122.            
  123.             string key = element.Attribute("Key");
  124.             if (key != null)
  125.                 m_publicKeyBlob = new StrongNamePublicKeyBlob(System.Security.Util.Hex.DecodeHexString(key));
  126.            
  127.             m_name = element.Attribute("Name");
  128.            
  129.             string version = element.Attribute("Version");
  130.             if (version != null)
  131.                 m_version = new Version(version);
  132.         }
  133.        
  134.         public override string ToString()
  135.         {
  136.             return ToXml().ToString();
  137.         }
  138.        
  139.         public override bool Equals(object o)
  140.         {
  141.             StrongName that = (o as StrongName);
  142.             return (that != null) && Equals(this.m_publicKeyBlob, that.m_publicKeyBlob) && Equals(this.m_name, that.m_name) && Equals(this.m_version, that.m_version);
  143.         }
  144.        
  145.         public override int GetHashCode()
  146.         {
  147.             if (m_publicKeyBlob != null) {
  148.                 return m_publicKeyBlob.GetHashCode();
  149.             }
  150.             else if (m_name != null || m_version != null) {
  151.                 return (m_name == null ? 0 : m_name.GetHashCode()) + (m_version == null ? 0 : m_version.GetHashCode());
  152.             }
  153.             else {
  154.                 return typeof(StrongName).GetHashCode();
  155.             }
  156.         }
  157.        
  158.         /// <internalonly/>
  159.         int IBuiltInEvidence.OutputToBuffer(char[] buffer, int position, bool verbose)
  160.         {
  161.             // StrongNames have a byte[], a string, and a Version (4 ints).
  162.             // Copy in the id, the byte[], the four ints, and then the string.
  163.            
  164.             buffer[position++] = BuiltInEvidenceHelper.idStrongName;
  165.             int lengthPK = m_publicKeyBlob.PublicKey.Length;
  166.             if (verbose) {
  167.                 BuiltInEvidenceHelper.CopyIntToCharArray(lengthPK, buffer, position);
  168.                 position += 2;
  169.             }
  170.             Buffer.InternalBlockCopy(m_publicKeyBlob.PublicKey, 0, buffer, position * 2, lengthPK);
  171.             position += ((lengthPK - 1) / 2) + 1;
  172.            
  173.             BuiltInEvidenceHelper.CopyIntToCharArray(m_version.Major, buffer, position);
  174.             BuiltInEvidenceHelper.CopyIntToCharArray(m_version.Minor, buffer, position + 2);
  175.             BuiltInEvidenceHelper.CopyIntToCharArray(m_version.Build, buffer, position + 4);
  176.             BuiltInEvidenceHelper.CopyIntToCharArray(m_version.Revision, buffer, position + 6);
  177.            
  178.             position += 8;
  179.             int lengthName = m_name.Length;
  180.             if (verbose) {
  181.                 BuiltInEvidenceHelper.CopyIntToCharArray(lengthName, buffer, position);
  182.                 position += 2;
  183.             }
  184.             m_name.CopyTo(0, buffer, position, lengthName);
  185.            
  186.             return lengthName + position;
  187.         }
  188.        
  189.         /// <internalonly/>
  190.         int IBuiltInEvidence.GetRequiredSize(bool verbose)
  191.         {
  192.             int length = ((m_publicKeyBlob.PublicKey.Length - 1) / 2) + 1;
  193.             // blob
  194.             if (verbose)
  195.                 length += 2;
  196.             // length of blob
  197.             length += 8;
  198.             // version
  199.             length += m_name.Length;
  200.             // Name
  201.             if (verbose)
  202.                 length += 2;
  203.             // length of name
  204.             length += 1;
  205.             // identifier
  206.             return length;
  207.         }
  208.        
  209.         /// <internalonly/>
  210.         int IBuiltInEvidence.InitFromBuffer(char[] buffer, int position)
  211.         {
  212.             int length = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position);
  213.             position += 2;
  214.             m_publicKeyBlob = new StrongNamePublicKeyBlob();
  215.             m_publicKeyBlob.PublicKey = new byte[length];
  216.            
  217.             int lengthInChars = ((length - 1) / 2) + 1;
  218.             Buffer.InternalBlockCopy(buffer, position * 2, m_publicKeyBlob.PublicKey, 0, length);
  219.             position += lengthInChars;
  220.            
  221.             int major = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position);
  222.             int minor = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position + 2);
  223.             int build = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position + 4);
  224.             int revision = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position + 6);
  225.             m_version = new Version(major, minor, build, revision);
  226.             position += 8;
  227.            
  228.             length = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position);
  229.             position += 2;
  230.            
  231.             m_name = new string(buffer, position, length);
  232.            
  233.             return position + length;
  234.         }
  235.        
  236.         // INormalizeForIsolatedStorage is not implemented for startup perf
  237.         // equivalent to INormalizeForIsolatedStorage.Normalize()
  238.         internal object Normalize()
  239.         {
  240.             MemoryStream ms = new MemoryStream();
  241.             BinaryWriter bw = new BinaryWriter(ms);
  242.            
  243.             bw.Write(m_publicKeyBlob.PublicKey);
  244.             bw.Write(m_version.Major);
  245.             bw.Write(m_name);
  246.            
  247.             ms.Position = 0;
  248.             return ms;
  249.         }
  250.     }
  251. }

Developer Fusion