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 \ ApplicationTrustEnumerator

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. // ApplicationTrust.cs
  18. //
  19. // This class encapsulates security decisions about an application.
  20. //
  22. namespace System.Security.Policy
  23. {
  24.     using System.Collections;
  25.     using System.Deployment.Internal.Isolation;
  26.     using System.Deployment.Internal.Isolation.Manifest;
  27.     using System.Globalization;
  28.     using System.IO;
  29.     using System.Runtime.InteropServices;
  30.     using System.Runtime.Serialization.Formatters.Binary;
  31.     using System.Security.Permissions;
  32.     using System.Security.Util;
  33.     using System.Text;
  34.     using System.Threading;
  35.    
  36.     [System.Runtime.InteropServices.ComVisible(true)]
  37.     public enum ApplicationVersionMatch
  38.     {
  39.         MatchExactVersion,
  40.         MatchAllVersions
  41.     }
  42.    
  43.     [System.Runtime.InteropServices.ComVisible(true)]
  44.     public sealed class ApplicationTrust : ISecurityEncodable
  45.     {
  46.         private ApplicationIdentity m_appId;
  47.         private bool m_appTrustedToRun;
  48.         private bool m_persist;
  49.         private object m_extraInfo;
  50.         private SecurityElement m_elExtraInfo;
  51.         private PolicyStatement m_psDefaultGrant;
  52.         private StrongName[] m_fullTrustAssemblies;
  53.        
  54.         public ApplicationTrust(ApplicationIdentity applicationIdentity) : this()
  55.         {
  56.             ApplicationIdentity = applicationIdentity;
  57.         }
  58.        
  59.         public ApplicationTrust() : this(new PermissionSet(PermissionState.None))
  60.         {
  61.         }
  62.         internal ApplicationTrust(PermissionSet defaultGrantSet) : this(defaultGrantSet, null)
  63.         {
  64.         }
  65.         internal ApplicationTrust(PermissionSet defaultGrantSet, StrongName[] fullTrustAssemblies)
  66.         {
  67.             DefaultGrantSet = new PolicyStatement(defaultGrantSet);
  68.             FullTrustAssemblies = fullTrustAssemblies;
  69.         }
  70.        
  71.         public ApplicationIdentity ApplicationIdentity {
  72.             get { return m_appId; }
  73.             set {
  74.                 if (value == null)
  75.                     throw new ArgumentNullException(Environment.GetResourceString("Argument_InvalidAppId"));
  76.                 m_appId = value;
  77.             }
  78.         }
  79.        
  80.         public PolicyStatement DefaultGrantSet {
  81.             get {
  82.                 if (m_psDefaultGrant == null)
  83.                     return new PolicyStatement(new PermissionSet(PermissionState.None));
  84.                 return m_psDefaultGrant;
  85.             }
  86.             set {
  87.                 if (value == null)
  88.                     m_psDefaultGrant = null;
  89.                 else
  90.                     m_psDefaultGrant = value;
  91.             }
  92.         }
  93.        
  94.         internal StrongName[] FullTrustAssemblies {
  95.             get { return m_fullTrustAssemblies; }
  96.             set { m_fullTrustAssemblies = value; }
  97.         }
  98.        
  99.         public bool IsApplicationTrustedToRun {
  100.             get { return m_appTrustedToRun; }
  101.             set { m_appTrustedToRun = value; }
  102.         }
  103.        
  104.         public bool Persist {
  105.             get { return m_persist; }
  106.             set { m_persist = value; }
  107.         }
  108.        
  109.         public object ExtraInfo {
  110.             get {
  111.                 if (m_elExtraInfo != null) {
  112.                     m_extraInfo = ObjectFromXml(m_elExtraInfo);
  113.                     m_elExtraInfo = null;
  114.                 }
  115.                 return m_extraInfo;
  116.             }
  117.             set {
  118.                 m_elExtraInfo = null;
  119.                 m_extraInfo = value;
  120.             }
  121.         }
  122.        
  123.         public SecurityElement ToXml()
  124.         {
  125.             SecurityElement elRoot = new SecurityElement("ApplicationTrust");
  126.             elRoot.AddAttribute("version", "1");
  127.            
  128.             if (m_appId != null)
  129.                 elRoot.AddAttribute("FullName", SecurityElement.Escape(m_appId.FullName));
  130.             if (m_appTrustedToRun)
  131.                 elRoot.AddAttribute("TrustedToRun", "true");
  132.             if (m_persist)
  133.                 elRoot.AddAttribute("Persist", "true");
  134.            
  135.             if (m_psDefaultGrant != null) {
  136.                 SecurityElement elDefaultGrant = new SecurityElement("DefaultGrant");
  137.                 elDefaultGrant.AddChild(m_psDefaultGrant.ToXml());
  138.                 elRoot.AddChild(elDefaultGrant);
  139.             }
  140.             if (m_fullTrustAssemblies != null) {
  141.                 SecurityElement elFullTrustAssemblies = new SecurityElement("FullTrustAssemblies");
  142.                 for (int index = 0; index < m_fullTrustAssemblies.Length; index++) {
  143.                     if (m_fullTrustAssemblies[index] != null)
  144.                         elFullTrustAssemblies.AddChild(m_fullTrustAssemblies[index].ToXml());
  145.                 }
  146.                 elRoot.AddChild(elFullTrustAssemblies);
  147.             }
  148.             if (ExtraInfo != null)
  149.                 elRoot.AddChild(ObjectToXml("ExtraInfo", ExtraInfo));
  150.            
  151.             return elRoot;
  152.         }
  153.        
  154.         public void FromXml(SecurityElement element)
  155.         {
  156.             if (element == null)
  157.                 throw new ArgumentNullException("element");
  158.             if (String.Compare(element.Tag, "ApplicationTrust", StringComparison.Ordinal) != 0)
  159.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidXML"));
  160.            
  161.             m_psDefaultGrant = null;
  162.             m_fullTrustAssemblies = null;
  163.             m_appTrustedToRun = false;
  164.            
  165.             string isAppTrustedToRun = element.Attribute("TrustedToRun");
  166.             if (isAppTrustedToRun != null && String.Compare(isAppTrustedToRun, "true", StringComparison.Ordinal) == 0)
  167.                 m_appTrustedToRun = true;
  168.             string persist = element.Attribute("Persist");
  169.             if (persist != null && String.Compare(persist, "true", StringComparison.Ordinal) == 0)
  170.                 m_persist = true;
  171.            
  172.             string fullName = element.Attribute("FullName");
  173.             if (fullName != null && fullName.Length > 0)
  174.                 m_appId = new ApplicationIdentity(fullName);
  175.            
  176.             SecurityElement elDefaultGrant = element.SearchForChildByTag("DefaultGrant");
  177.             if (elDefaultGrant != null) {
  178.                 SecurityElement elDefaultGrantPS = elDefaultGrant.SearchForChildByTag("PolicyStatement");
  179.                 if (elDefaultGrantPS != null) {
  180.                     PolicyStatement ps = new PolicyStatement(null);
  181.                     ps.FromXml(elDefaultGrantPS);
  182.                     m_psDefaultGrant = ps;
  183.                 }
  184.             }
  185.            
  186.             SecurityElement elFullTrustAssemblies = element.SearchForChildByTag("FullTrustAssemblies");
  187.             if (elFullTrustAssemblies != null && elFullTrustAssemblies.InternalChildren != null) {
  188.                 m_fullTrustAssemblies = new StrongName[elFullTrustAssemblies.Children.Count];
  189.                 IEnumerator enumerator = elFullTrustAssemblies.Children.GetEnumerator();
  190.                 int index = 0;
  191.                 while (enumerator.MoveNext()) {
  192.                     m_fullTrustAssemblies[index] = new StrongName();
  193.                     m_fullTrustAssemblies[index].FromXml(enumerator.Current as SecurityElement);
  194.                     index++;
  195.                 }
  196.             }
  197.            
  198.             m_elExtraInfo = element.SearchForChildByTag("ExtraInfo");
  199.         }
  200.        
  201.         private static SecurityElement ObjectToXml(string tag, object obj)
  202.         {
  203.             BCLDebug.Assert(obj != null, "You need to pass in an object");
  204.            
  205.             ISecurityEncodable encodableObj = obj as ISecurityEncodable;
  206.            
  207.             SecurityElement elObject;
  208.             if (encodableObj != null) {
  209.                 elObject = encodableObj.ToXml();
  210.                 if (!elObject.Tag.Equals(tag))
  211.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidXML"));
  212.             }
  213.            
  214.             MemoryStream stream = new MemoryStream();
  215.             BinaryFormatter formatter = new BinaryFormatter();
  216.             formatter.Serialize(stream, obj);
  217.             byte[] array = stream.ToArray();
  218.            
  219.             elObject = new SecurityElement(tag);
  220.             elObject.AddAttribute("Data", Hex.EncodeHexString(array));
  221.             return elObject;
  222.         }
  223.        
  224.        
  225.         private static object ObjectFromXml(SecurityElement elObject)
  226.         {
  227.             BCLDebug.Assert(elObject != null, "You need to pass in a security element");
  228.            
  229.             if (elObject.Attribute("class") != null) {
  230.                 ISecurityEncodable encodableObj = XMLUtil.CreateCodeGroup(elObject) as ISecurityEncodable;
  231.                 if (encodableObj != null) {
  232.                     encodableObj.FromXml(elObject);
  233.                     return encodableObj;
  234.                 }
  235.             }
  236.            
  237.             string objectData = elObject.Attribute("Data");
  238.             MemoryStream stream = new MemoryStream(Hex.DecodeHexString(objectData));
  239.             BinaryFormatter formatter = new BinaryFormatter();
  240.             return formatter.Deserialize(stream);
  241.         }
  242.     }
  243.    
  244.     [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.ControlPolicy)]
  245.     [System.Runtime.InteropServices.ComVisible(true)]
  246.     public sealed class ApplicationTrustCollection : ICollection
  247.     {
  248.         private const string ApplicationTrustProperty = "ApplicationTrust";
  249.         private const string InstallerIdentifier = "{60051b8f-4f12-400a-8e50-dd05ebd438d1}";
  250.         private static Guid ClrPropertySet = new Guid("c989bb7a-8385-4715-98cf-a741a8edb823");
  251.        
  252.         // The CLR specific constant install reference.
  253.         private static object s_installReference = null;
  254.         private static StoreApplicationReference InstallReference {
  255.             get {
  256.                 if (s_installReference == null) {
  257.                     Interlocked.CompareExchange(ref s_installReference, new StoreApplicationReference(IsolationInterop.GUID_SXS_INSTALL_REFERENCE_SCHEME_OPAQUESTRING, InstallerIdentifier, null), null);
  258.                 }
  259.                 return (StoreApplicationReference)s_installReference;
  260.             }
  261.         }
  262.        
  263.         private readonly object m_syncRoot = new object();
  264.        
  265.         private object m_appTrusts = null;
  266.         private ArrayList AppTrusts {
  267.             get {
  268.                 if (m_appTrusts == null) {
  269.                     ArrayList appTrusts = new ArrayList();
  270.                     if (m_storeBounded) {
  271.                         RefreshStorePointer();
  272.                         // enumerate the user store and populate the collection
  273.                         StoreDeploymentMetadataEnumeration deplEnum = m_pStore.EnumInstallerDeployments(IsolationInterop.GUID_SXS_INSTALL_REFERENCE_SCHEME_OPAQUESTRING, InstallerIdentifier, ApplicationTrustProperty, null);
  274.                         foreach (IDefinitionAppId defAppId in deplEnum) {
  275.                             StoreDeploymentMetadataPropertyEnumeration metadataEnum = m_pStore.EnumInstallerDeploymentProperties(IsolationInterop.GUID_SXS_INSTALL_REFERENCE_SCHEME_OPAQUESTRING, InstallerIdentifier, ApplicationTrustProperty, defAppId);
  276.                             foreach (StoreOperationMetadataProperty appTrustProperty in metadataEnum) {
  277.                                 string appTrustXml = appTrustProperty.Value;
  278.                                 if (appTrustXml != null && appTrustXml.Length > 0) {
  279.                                     SecurityElement seTrust = SecurityElement.FromString(appTrustXml);
  280.                                     ApplicationTrust appTrust = new ApplicationTrust();
  281.                                     appTrust.FromXml(seTrust);
  282.                                     appTrusts.Add(appTrust);
  283.                                 }
  284.                             }
  285.                         }
  286.                     }
  287.                     Interlocked.CompareExchange(ref m_appTrusts, appTrusts, null);
  288.                 }
  289.                 return m_appTrusts as ArrayList;
  290.             }
  291.         }
  292.        
  293.         private bool m_storeBounded = false;
  294.         private Store m_pStore = null;
  295.         // Component store interface pointer.
  296.         // Only internal constructors are exposed.
  297.         internal ApplicationTrustCollection() : this(false)
  298.         {
  299.         }
  300.         internal ApplicationTrustCollection(bool storeBounded)
  301.         {
  302.             m_storeBounded = storeBounded;
  303.         }
  304.        
  305.         private void RefreshStorePointer()
  306.         {
  307.             // Refresh store pointer.
  308.             if (m_pStore != null)
  309.                 Marshal.ReleaseComObject(m_pStore.InternalStore);
  310.             m_pStore = IsolationInterop.GetUserStore();
  311.         }
  312.        
  313.         public int Count {
  314.             get { return AppTrusts.Count; }
  315.         }
  316.        
  317.         public ApplicationTrust this[int index]
  318.         {
  319.             get { return AppTrusts[index] as ApplicationTrust; }
  320.         }
  321.        
  322.         public ApplicationTrust this[string appFullName]
  323.         {
  324.             get {
  325.                 ApplicationIdentity identity = new ApplicationIdentity(appFullName);
  326.                 ApplicationTrustCollection appTrusts = Find(identity, ApplicationVersionMatch.MatchExactVersion);
  327.                 if (appTrusts.Count > 0)
  328.                     return appTrusts[0];
  329.                 return null;
  330.             }
  331.         }
  332.        
  333.         private void CommitApplicationTrust(ApplicationIdentity applicationIdentity, string trustXml)
  334.         {
  335.             StoreOperationMetadataProperty[] properties = new StoreOperationMetadataProperty[] {new StoreOperationMetadataProperty(ClrPropertySet, ApplicationTrustProperty, trustXml)};
  336.            
  337.             IEnumDefinitionIdentity idenum = applicationIdentity.Identity.EnumAppPath();
  338.             IDefinitionIdentity[] asbId = new IDefinitionIdentity[1];
  339.             IDefinitionIdentity deplId = null;
  340.             if (idenum.Next(1, asbId) == 1)
  341.                 deplId = asbId[0];
  342.            
  343.             IDefinitionAppId defAppId = IsolationInterop.AppIdAuthority.CreateDefinition();
  344.             defAppId.SetAppPath(1, new IDefinitionIdentity[] {deplId});
  345.             defAppId.put_Codebase(applicationIdentity.CodeBase);
  346.            
  347.             using (StoreTransaction storeTxn = new StoreTransaction()) {
  348.                 storeTxn.Add(new StoreOperationSetDeploymentMetadata(defAppId, InstallReference, properties));
  349.                 RefreshStorePointer();
  350.                 m_pStore.Transact(storeTxn.Operations);
  351.             }
  352.            
  353.             m_appTrusts = null;
  354.             // reset the app trusts in the collection.
  355.         }
  356.        
  357.         public int Add(ApplicationTrust trust)
  358.         {
  359.             if (trust == null)
  360.                 throw new ArgumentNullException("trust");
  361.             if (trust.ApplicationIdentity == null)
  362.                 throw new ArgumentException(Environment.GetResourceString("Argument_ApplicationTrustShouldHaveIdentity"));
  363.            
  364.             // Add the trust decision of the application to the fusion store.
  365.             if (m_storeBounded) {
  366.                 CommitApplicationTrust(trust.ApplicationIdentity, trust.ToXml().ToString());
  367.                 return -1;
  368.             }
  369.             else {
  370.                 return AppTrusts.Add(trust);
  371.             }
  372.         }
  373.        
  374.         public void AddRange(ApplicationTrust[] trusts)
  375.         {
  376.             if (trusts == null)
  377.                 throw new ArgumentNullException("trusts");
  378.            
  379.             int i = 0;
  380.             try {
  381.                 for (; i < trusts.Length; i++) {
  382.                     Add(trusts[i]);
  383.                 }
  384.             }
  385.             catch {
  386.                 for (int j = 0; j < i; j++) {
  387.                     Remove(trusts[j]);
  388.                 }
  389.                 throw;
  390.             }
  391.         }
  392.        
  393.         public void AddRange(ApplicationTrustCollection trusts)
  394.         {
  395.             if (trusts == null)
  396.                 throw new ArgumentNullException("trusts");
  397.            
  398.             int i = 0;
  399.             try {
  400.                 foreach (ApplicationTrust trust in trusts) {
  401.                     Add(trust);
  402.                     i++;
  403.                 }
  404.             }
  405.             catch {
  406.                 for (int j = 0; j < i; j++) {
  407.                     Remove(trusts[j]);
  408.                 }
  409.                 throw;
  410.             }
  411.         }
  412.        
  413.         public ApplicationTrustCollection Find(ApplicationIdentity applicationIdentity, ApplicationVersionMatch versionMatch)
  414.         {
  415.             ApplicationTrustCollection collection = new ApplicationTrustCollection(false);
  416.             foreach (ApplicationTrust trust in this) {
  417.                 if (CmsUtils.CompareIdentities(trust.ApplicationIdentity, applicationIdentity, versionMatch))
  418.                     collection.Add(trust);
  419.             }
  420.             return collection;
  421.         }
  422.        
  423.         public void Remove(ApplicationIdentity applicationIdentity, ApplicationVersionMatch versionMatch)
  424.         {
  425.             ApplicationTrustCollection collection = Find(applicationIdentity, versionMatch);
  426.             RemoveRange(collection);
  427.         }
  428.        
  429.         public void Remove(ApplicationTrust trust)
  430.         {
  431.             if (trust == null)
  432.                 throw new ArgumentNullException("trust");
  433.             if (trust.ApplicationIdentity == null)
  434.                 throw new ArgumentException(Environment.GetResourceString("Argument_ApplicationTrustShouldHaveIdentity"));
  435.            
  436.             // Remove the trust decision of the application from the fusion store.
  437.             if (m_storeBounded) {
  438.                 CommitApplicationTrust(trust.ApplicationIdentity, null);
  439.             }
  440.             else {
  441.                 AppTrusts.Remove(trust);
  442.             }
  443.         }
  444.        
  445.         public void RemoveRange(ApplicationTrust[] trusts)
  446.         {
  447.             if (trusts == null)
  448.                 throw new ArgumentNullException("trusts");
  449.            
  450.             int i = 0;
  451.             try {
  452.                 for (; i < trusts.Length; i++) {
  453.                     Remove(trusts[i]);
  454.                 }
  455.             }
  456.             catch {
  457.                 for (int j = 0; j < i; j++) {
  458.                     Add(trusts[j]);
  459.                 }
  460.                 throw;
  461.             }
  462.         }
  463.        
  464.         public void RemoveRange(ApplicationTrustCollection trusts)
  465.         {
  466.             if (trusts == null)
  467.                 throw new ArgumentNullException("trusts");
  468.            
  469.             int i = 0;
  470.             try {
  471.                 foreach (ApplicationTrust trust in trusts) {
  472.                     Remove(trust);
  473.                     i++;
  474.                 }
  475.             }
  476.             catch {
  477.                 for (int j = 0; j < i; j++) {
  478.                     Add(trusts[j]);
  479.                 }
  480.                 throw;
  481.             }
  482.         }
  483.        
  484.         public void Clear()
  485.         {
  486.             // remove all trust decisions in the collection.
  487.             ArrayList trusts = this.AppTrusts;
  488.             if (m_storeBounded) {
  489.                 foreach (ApplicationTrust trust in trusts) {
  490.                     if (trust.ApplicationIdentity == null)
  491.                         throw new ArgumentException(Environment.GetResourceString("Argument_ApplicationTrustShouldHaveIdentity"));
  492.                    
  493.                     // Remove the trust decision of the application from the fusion store.
  494.                     CommitApplicationTrust(trust.ApplicationIdentity, null);
  495.                 }
  496.             }
  497.             trusts.Clear();
  498.         }
  499.        
  500.         public ApplicationTrustEnumerator GetEnumerator()
  501.         {
  502.             return new ApplicationTrustEnumerator(this);
  503.         }
  504.        
  505.         /// <internalonly/>
  506.         IEnumerator IEnumerable.GetEnumerator()
  507.         {
  508.             return new ApplicationTrustEnumerator(this);
  509.         }
  510.        
  511.         /// <internalonly/>
  512.         void ICollection.CopyTo(Array array, int index)
  513.         {
  514.             if (array == null)
  515.                 throw new ArgumentNullException("array");
  516.             if (array.Rank != 1)
  517.                 throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
  518.             if (index < 0 || index >= array.Length)
  519.                 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  520.             if (array.Length - index < this.Count)
  521.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  522.            
  523.             for (int i = 0; i < this.Count; i++) {
  524.                 array.SetValue(this[i], index++);
  525.             }
  526.         }
  527.        
  528.         public void CopyTo(ApplicationTrust[] array, int index)
  529.         {
  530.             ((ICollection)this).CopyTo(array, index);
  531.         }
  532.        
  533.         public bool IsSynchronized {
  534.             get { return false; }
  535.         }
  536.        
  537.         public object SyncRoot {
  538.             get { return this; }
  539.         }
  540.     }
  541.    
  542.     [System.Runtime.InteropServices.ComVisible(true)]
  543.     public sealed class ApplicationTrustEnumerator : IEnumerator
  544.     {
  545.         private ApplicationTrustCollection m_trusts;
  546.         private int m_current;
  547.        
  548.         private ApplicationTrustEnumerator()
  549.         {
  550.         }
  551.         internal ApplicationTrustEnumerator(ApplicationTrustCollection trusts)
  552.         {
  553.             m_trusts = trusts;
  554.             m_current = -1;
  555.         }
  556.        
  557.         public ApplicationTrust Current {
  558.             get { return m_trusts[m_current]; }
  559.         }
  560.        
  561.         /// <internalonly/>
  562.         object IEnumerator.Current {
  563.             get { return (object)m_trusts[m_current]; }
  564.         }
  565.        
  566.         public bool MoveNext()
  567.         {
  568.             if (m_current == ((int)m_trusts.Count - 1))
  569.                 return false;
  570.             m_current++;
  571.             return true;
  572.         }
  573.        
  574.         public void Reset()
  575.         {
  576.             m_current = -1;
  577.         }
  578.     }
  579. }

Developer Fusion