public void AddRange(ApplicationTrustCollection trusts) { if (trusts == null) { throw new ArgumentNullException("trusts"); } int num = 0; try { ApplicationTrustEnumerator enumerator = trusts.GetEnumerator(); while (enumerator.MoveNext()) { ApplicationTrust current = enumerator.Current; this.Add(current); num++; } } catch { for (int i = 0; i < num; i++) { this.Remove(trusts[i]); } throw; } }
public void ApplicationIdentity_Null () { ApplicationTrust at = new ApplicationTrust (); at.ApplicationIdentity = new ApplicationIdentity ("Mono Unit Test"); // once set it cannot be "unset" ... at.ApplicationIdentity = null; }
internal static ApplicationTrust DetermineApplicationTrustInternal(ActivationContext activationContext, TrustManagerContext context) { ApplicationTrustCollection applicationTrustCollection = new ApplicationTrustCollection(true); ApplicationTrust applicationTrust; if (context == null || !context.IgnorePersistedDecision) { applicationTrust = applicationTrustCollection[activationContext.Identity.FullName]; if (applicationTrust != null) { return(applicationTrust); } } applicationTrust = ApplicationSecurityManager.ApplicationTrustManager.DetermineApplicationTrust(activationContext, context); if (applicationTrust == null) { applicationTrust = new ApplicationTrust(activationContext.Identity); } applicationTrust.ApplicationIdentity = activationContext.Identity; if (applicationTrust.Persist) { applicationTrustCollection.Add(applicationTrust); } return(applicationTrust); }
public static void ApplicationTrustCallMethods() { ApplicationTrust at = new ApplicationTrust(); SecurityElement se = new SecurityElement(""); at.FromXml(se); se = at.ToXml(); }
/// <summary>Gets the application trusts in the collection that match the specified application identity.</summary> /// <returns>An <see cref="T:System.Security.Policy.ApplicationTrustCollection" /> containing all matching <see cref="T:System.Security.Policy.ApplicationTrust" /> objects.</returns> /// <param name="applicationIdentity">An <see cref="T:System.ApplicationIdentity" /> object describing the application to find.</param> /// <param name="versionMatch">One of the <see cref="T:System.Security.Policy.ApplicationVersionMatch" /> values. </param> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Read="*AllFiles*" PathDiscovery="*AllFiles*" /> /// <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="MemberAccess" /> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence, ControlPolicy" /> /// </PermissionSet> public ApplicationTrustCollection Find(ApplicationIdentity applicationIdentity, ApplicationVersionMatch versionMatch) { if (applicationIdentity == null) { throw new ArgumentNullException("applicationIdentity"); } string text = applicationIdentity.FullName; if (versionMatch != ApplicationVersionMatch.MatchExactVersion) { if (versionMatch != ApplicationVersionMatch.MatchAllVersions) { throw new ArgumentException("versionMatch"); } int num = text.IndexOf(", Version="); if (num >= 0) { text = text.Substring(0, num); } } ApplicationTrustCollection applicationTrustCollection = new ApplicationTrustCollection(); foreach (object obj in this._list) { ApplicationTrust applicationTrust = (ApplicationTrust)obj; if (applicationTrust.ApplicationIdentity.FullName.StartsWith(text)) { applicationTrustCollection.Add(applicationTrust); } } return(applicationTrustCollection); }
public static bool DetermineApplicationTrust(ActivationContext activationContext, TrustManagerContext context) { if (activationContext == null) { throw new ArgumentNullException("activationContext"); } ApplicationTrust appTrust = null; AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager; if (domainManager != null) { HostSecurityManager securityManager = domainManager.HostSecurityManager; if ((securityManager != null) && ((securityManager.Flags & HostSecurityManagerOptions.HostDetermineApplicationTrust) == HostSecurityManagerOptions.HostDetermineApplicationTrust)) { appTrust = securityManager.DetermineApplicationTrust(CmsUtils.MergeApplicationEvidence(null, activationContext.Identity, activationContext, null), null, context); if (appTrust == null) { return(false); } return(appTrust.IsApplicationTrustedToRun); } } appTrust = DetermineApplicationTrustInternal(activationContext, context); if (appTrust == null) { return(false); } return(appTrust.IsApplicationTrustedToRun); }
// // Internal // internal static ApplicationTrust DetermineApplicationTrustInternal(ActivationContext activationContext, TrustManagerContext context) { ApplicationTrust trust = null; ApplicationTrustCollection userTrusts = new ApplicationTrustCollection(true); // See if there is a persisted trust decision for this application. if ((context == null || !context.IgnorePersistedDecision)) { trust = userTrusts[activationContext.Identity.FullName]; if (trust != null) { return(trust); } } // There is no cached trust decision so invoke the trust manager. trust = ApplicationTrustManager.DetermineApplicationTrust(activationContext, context); if (trust == null) { trust = new ApplicationTrust(activationContext.Identity); } // make sure the application identity is correctly set. trust.ApplicationIdentity = activationContext.Identity; if (trust.Persist) { userTrusts.Add(trust); } return(trust); }
internal static ApplicationTrust DetermineApplicationTrustInternal(ActivationContext activationContext, TrustManagerContext context) { ApplicationTrust trust = null; ApplicationTrustCollection trusts = new ApplicationTrustCollection(true); if ((context == null) || !context.IgnorePersistedDecision) { trust = trusts[activationContext.Identity.FullName]; if (trust != null) { return(trust); } } trust = ApplicationTrustManager.DetermineApplicationTrust(activationContext, context); if (trust == null) { trust = new ApplicationTrust(activationContext.Identity); } trust.ApplicationIdentity = activationContext.Identity; if (trust.Persist) { trusts.Add(trust); } return(trust); }
private static bool ExistingTrustApplicable(ApplicationSecurityInfo info, ArrayList matchingTrusts) { int index = 0; while (index < matchingTrusts.Count) { ApplicationTrust trust = (ApplicationTrust)matchingTrusts[index]; if (!trust.IsApplicationTrustedToRun) { matchingTrusts.RemoveAt(index); } PermissionSet requestedPermissionSet = GetRequestedPermissionSet(info); PermissionSet permissionSet = trust.DefaultGrantSet.PermissionSet; if ((permissionSet == null) && (requestedPermissionSet != null)) { matchingTrusts.RemoveAt(index); } else if ((permissionSet != null) && (requestedPermissionSet == null)) { index++; continue; } if (requestedPermissionSet.IsSubsetOf(permissionSet)) { index++; } else { matchingTrusts.RemoveAt(index); } } return(matchingTrusts.Count > 0); }
public void ApplicationIdentity () { ApplicationTrust at = new ApplicationTrust (); at.ApplicationIdentity = new ApplicationIdentity ("Mono Unit Test"); Assert.IsNotNull (at.ApplicationIdentity, "not null"); string expected = AdjustLineEnds ("<ApplicationTrust version=\"1\"\r\nFullName=\"Mono Unit Test, Culture=neutral\">\r\n<DefaultGrant>\r\n<PolicyStatement version=\"1\">\r\n<PermissionSet class=\"System.Security.PermissionSet\"\r\nversion=\"1\"/>\r\n</PolicyStatement>\r\n</DefaultGrant>\r\n</ApplicationTrust>\r\n"); Assert.AreEqual (expected, AdjustLineEnds (at.ToXml ().ToString ()), "XML"); }
public static bool DetermineApplicationTrust(ActivationContext activationContext, TrustManagerContext context) { if (activationContext == null) { throw new NullReferenceException("activationContext"); } ApplicationTrust applicationTrust = ApplicationSecurityManager.ApplicationTrustManager.DetermineApplicationTrust(activationContext, context); return(applicationTrust.IsApplicationTrustedToRun); }
// helpers internal void RemoveAllInstances(ApplicationTrust trust) { for (int i = _list.Count - 1; i >= 0; i--) { if (trust.Equals(_list [i])) { _list.RemoveAt(i); } } }
// methods public int Add (ApplicationTrust trust) { if (trust == null) throw new ArgumentNullException ("trust"); if (trust.ApplicationIdentity == null) { throw new ArgumentException (Locale.GetText ( "ApplicationTrust.ApplicationIdentity can't be null."), "trust"); } return _list.Add (trust); }
internal void InternalSetApplicationTrust(System.Security.Policy.ApplicationTrust value) { if (value != null) { this._ApplicationTrust = value.ToXml().ToString(); } else { this._ApplicationTrust = null; } }
/// <summary>Adds an element to the collection.</summary> /// <returns>The index at which the new element was inserted.</returns> /// <param name="trust">The <see cref="T:System.Security.Policy.ApplicationTrust" /> object to add.</param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="trust" /> is null.</exception> /// <exception cref="T:System.ArgumentException">The <see cref="P:System.Security.Policy.ApplicationTrust.ApplicationIdentity" /> property of the <see cref="T:System.Security.Policy.ApplicationTrust" /> specified in <paramref name="trust" /> is null.</exception> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Read="*AllFiles*" PathDiscovery="*AllFiles*" /> /// <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="MemberAccess" /> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence, ControlPolicy" /> /// </PermissionSet> public int Add(ApplicationTrust trust) { if (trust == null) { throw new ArgumentNullException("trust"); } if (trust.ApplicationIdentity == null) { throw new ArgumentException(Locale.GetText("ApplicationTrust.ApplicationIdentity can't be null."), "trust"); } return(this._list.Add(trust)); }
public static bool DetermineApplicationTrust(ActivationContext activationContext, TrustManagerContext context) { // FIXME: a null activationContext throw a NullReferenceException but calling directly the ApplicationTrustManager.DetermineApplicationTrust doesn't if (activationContext == null) { throw new NullReferenceException("activationContext"); } // throw new ArgumentNullException ("activationContext"); ApplicationTrust at = ApplicationTrustManager.DetermineApplicationTrust(activationContext, context); return(at.IsApplicationTrustedToRun); }
public static System.Security.Policy.ApplicationTrust PersistTrustWithoutEvaluation(ActivationContext actCtx) { ApplicationSecurityInfo applicationSecurityInfo = new ApplicationSecurityInfo(actCtx); System.Security.Policy.ApplicationTrust trust = new System.Security.Policy.ApplicationTrust(actCtx.Identity); trust.IsApplicationTrustedToRun = true; trust.DefaultGrantSet = new PolicyStatement(applicationSecurityInfo.DefaultRequestSet, PolicyStatementAttribute.Nothing); trust.Persist = true; trust.ApplicationIdentity = actCtx.Identity; ApplicationSecurityManager.UserApplicationTrusts.Add(trust); return(trust); }
/// <summary>Removes the specified application trust from the collection.</summary> /// <param name="trust">The <see cref="T:System.Security.Policy.ApplicationTrust" /> object to remove.</param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="trust" /> is null.</exception> /// <exception cref="T:System.ArgumentException">The <see cref="P:System.Security.Policy.ApplicationTrust.ApplicationIdentity" /> property of the <see cref="T:System.Security.Policy.ApplicationTrust" /> object specified by <paramref name="trust" /> is null.</exception> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence, ControlPolicy" /> /// </PermissionSet> public void Remove(ApplicationTrust trust) { if (trust == null) { throw new ArgumentNullException("trust"); } if (trust.ApplicationIdentity == null) { throw new ArgumentException(Locale.GetText("ApplicationTrust.ApplicationIdentity can't be null."), "trust"); } this.RemoveAllInstances(trust); }
public static System.Security.Policy.ApplicationTrust PersistTrustWithoutEvaluation(ActivationContext actCtx) { ApplicationSecurityInfo info = new ApplicationSecurityInfo(actCtx); System.Security.Policy.ApplicationTrust trust = new System.Security.Policy.ApplicationTrust(actCtx.Identity) { IsApplicationTrustedToRun = true, DefaultGrantSet = new PolicyStatement(info.DefaultRequestSet, PolicyStatementAttribute.Nothing), Persist = true, ApplicationIdentity = actCtx.Identity }; ApplicationSecurityManager.UserApplicationTrusts.Add(trust); return trust; }
internal System.Security.Policy.ApplicationTrust InternalGetApplicationTrust() { if (this._ApplicationTrust == null) { return(null); } SecurityElement element = SecurityElement.FromString(this._ApplicationTrust); System.Security.Policy.ApplicationTrust trust = new System.Security.Policy.ApplicationTrust(); trust.FromXml(element); return(trust); }
public ApplicationTrust this [string appFullName] { get { for (int i = 0; i < _list.Count; i++) { ApplicationTrust at = (_list [i] as ApplicationTrust); if (at.ApplicationIdentity.FullName == appFullName) { return(at); } } return(null); } }
public void Constructor_Empty () { ApplicationTrust at = new ApplicationTrust (); Assert.IsNull (at.ApplicationIdentity, "ApplicationIdentity"); Assert.AreEqual (PolicyStatementAttribute.Nothing, at.DefaultGrantSet.Attributes, "DefaultGrantSet.Attributes"); Assert.AreEqual (String.Empty, at.DefaultGrantSet.AttributeString, "DefaultGrantSet.AttributeString"); Assert.IsTrue (at.DefaultGrantSet.PermissionSet.IsEmpty (), "DefaultGrantSet.PermissionSet.IsEmpty"); Assert.IsFalse (at.DefaultGrantSet.PermissionSet.IsUnrestricted (), "DefaultGrantSet.PermissionSet.IsUnrestricted"); Assert.IsNull (at.ExtraInfo, "ExtraInfo"); Assert.IsFalse (at.IsApplicationTrustedToRun, "IsApplicationTrustedToRun"); Assert.IsFalse (at.Persist, "Persist"); string expected = AdjustLineEnds ("<ApplicationTrust version=\"1\">\r\n<DefaultGrant>\r\n<PolicyStatement version=\"1\">\r\n<PermissionSet class=\"System.Security.PermissionSet\"\r\nversion=\"1\"/>\r\n</PolicyStatement>\r\n</DefaultGrant>\r\n</ApplicationTrust>\r\n"); Assert.AreEqual (expected, AdjustLineEnds (at.ToXml ().ToString ()), "XML"); }
public static void ApplicationTrustCollectionCallMethods() { ApplicationTrustCollection atc = (ApplicationTrustCollection)Activator.CreateInstance(typeof(ApplicationTrustCollection), true); ApplicationTrust at = new ApplicationTrust(); int testint = atc.Add(at); ApplicationTrust[] atarray = new ApplicationTrust[1]; atc.AddRange(atarray); atc.AddRange(atc); atc.Clear(); atc.CopyTo(atarray, 0); ApplicationTrustEnumerator ate = atc.GetEnumerator(); atc.Remove(at); atc.RemoveRange(atarray); atc.RemoveRange(atc); }
public ApplicationTrustCollection Find(ApplicationIdentity applicationIdentity, ApplicationVersionMatch versionMatch) { ApplicationTrustCollection trusts = new ApplicationTrustCollection(false); ApplicationTrustEnumerator enumerator = this.GetEnumerator(); while (enumerator.MoveNext()) { ApplicationTrust current = enumerator.Current; if (CmsUtils.CompareIdentities(current.ApplicationIdentity, applicationIdentity, versionMatch)) { trusts.Add(current); } } return(trusts); }
public static System.Security.Policy.ApplicationTrust RequestTrust(SubscriptionState subState, bool isShellVisible, bool isUpdate, ActivationContext actCtx, TrustManagerContext tmc) { Logger.AddMethodCall("ApplicationTrust.RequestTrust(isShellVisible=" + isShellVisible.ToString() + ", isUpdate=" + isUpdate.ToString() + ", subState.IsInstalled=" + subState.IsInstalled.ToString() + ") called."); if (!subState.IsInstalled || subState.IsShellVisible != isShellVisible) { tmc.IgnorePersistedDecision = true; } if (isUpdate) { tmc.PreviousApplicationIdentity = subState.CurrentBind.ToApplicationIdentity(); } bool applicationTrust1; try { Logger.AddInternalState("Calling ApplicationSecurityManager.DetermineApplicationTrust()."); Logger.AddInternalState("Trust Manager Context=" + Logger.Serialize(tmc)); applicationTrust1 = ApplicationSecurityManager.DetermineApplicationTrust(actCtx, tmc); } catch (TypeLoadException ex) { throw new InvalidDeploymentException(Resources.GetString("Ex_InvalidTrustInfo"), (Exception)ex); } if (!applicationTrust1) { throw new TrustNotGrantedException(Resources.GetString("Ex_NoTrust")); } Logger.AddInternalState("Trust granted."); System.Security.Policy.ApplicationTrust applicationTrust2 = (System.Security.Policy.ApplicationTrust)null; for (int index = 0; index < 5; ++index) { applicationTrust2 = ApplicationSecurityManager.UserApplicationTrusts[actCtx.Identity.FullName]; if (applicationTrust2 == null) { Thread.Sleep(10); } else { break; } } if (applicationTrust2 == null) { throw new InvalidDeploymentException(Resources.GetString("Ex_InvalidMatchTrust")); } return(applicationTrust2); }
public void Clear() { ArrayList appTrusts = this.AppTrusts; if (this.m_storeBounded) { foreach (object obj in appTrusts) { ApplicationTrust applicationTrust = (ApplicationTrust)obj; if (applicationTrust.ApplicationIdentity == null) { throw new ArgumentException(Environment.GetResourceString("Argument_ApplicationTrustShouldHaveIdentity")); } this.CommitApplicationTrust(applicationTrust.ApplicationIdentity, null); } } appTrusts.Clear(); }
public int Add(ApplicationTrust trust) { if (trust == null) { throw new ArgumentNullException("trust"); } if (trust.ApplicationIdentity == null) { throw new ArgumentException(Environment.GetResourceString("Argument_ApplicationTrustShouldHaveIdentity")); } if (this.m_storeBounded) { this.CommitApplicationTrust(trust.ApplicationIdentity, trust.ToXml().ToString()); return -1; } return this.AppTrusts.Add(trust); }
public void Remove(ApplicationTrust trust) { if (trust == null) { throw new ArgumentNullException("trust"); } if (trust.ApplicationIdentity == null) { throw new ArgumentException(Environment.GetResourceString("Argument_ApplicationTrustShouldHaveIdentity")); } if (this.m_storeBounded) { this.CommitApplicationTrust(trust.ApplicationIdentity, null); return; } this.AppTrusts.Remove(trust); }
public void Remove(ApplicationTrust trust) { if (trust == null) { throw new ArgumentNullException("trust"); } if (trust.ApplicationIdentity == null) { throw new ArgumentException(Environment.GetResourceString("Argument_ApplicationTrustShouldHaveIdentity")); } // Remove the trust decision of the application from the fusion store. if (m_storeBounded) { CommitApplicationTrust(trust.ApplicationIdentity, null); } else { AppTrusts.Remove(trust); } }
private static bool SearchPreviousTrustedVersion(ActivationContext activationContext, ApplicationIdentity previousAppId, out ArrayList matchingTrusts) { matchingTrusts = null; ApplicationTrustCollection userApplicationTrusts = ApplicationSecurityManager.UserApplicationTrusts; ApplicationTrustEnumerator enumerator = userApplicationTrusts.GetEnumerator(); while (enumerator.MoveNext()) { ApplicationTrust current = enumerator.Current; System.Deployment.Internal.Isolation.IDefinitionAppId id = System.Deployment.Internal.Isolation.IsolationInterop.AppIdAuthority.TextToDefinition(0, current.ApplicationIdentity.FullName); System.Deployment.Internal.Isolation.IDefinitionAppId id2 = System.Deployment.Internal.Isolation.IsolationInterop.AppIdAuthority.TextToDefinition(0, activationContext.Identity.FullName); if (System.Deployment.Internal.Isolation.IsolationInterop.AppIdAuthority.AreDefinitionsEqual(1, id, id2)) { if (matchingTrusts == null) { matchingTrusts = new ArrayList(); } matchingTrusts.Add(current); } } if (previousAppId != null) { ApplicationTrustEnumerator enumerator2 = userApplicationTrusts.GetEnumerator(); while (enumerator2.MoveNext()) { ApplicationTrust trust2 = enumerator2.Current; System.Deployment.Internal.Isolation.IDefinitionAppId id3 = System.Deployment.Internal.Isolation.IsolationInterop.AppIdAuthority.TextToDefinition(0, trust2.ApplicationIdentity.FullName); System.Deployment.Internal.Isolation.IDefinitionAppId id4 = System.Deployment.Internal.Isolation.IsolationInterop.AppIdAuthority.TextToDefinition(0, previousAppId.FullName); if (System.Deployment.Internal.Isolation.IsolationInterop.AppIdAuthority.AreDefinitionsEqual(1, id3, id4)) { if (matchingTrusts == null) { matchingTrusts = new ArrayList(); } matchingTrusts.Add(trust2); } } } return(matchingTrusts != null); }
public int Add(ApplicationTrust trust) { if (trust == null) { throw new ArgumentNullException("trust"); } if (trust.ApplicationIdentity == null) { throw new ArgumentException(Environment.GetResourceString("Argument_ApplicationTrustShouldHaveIdentity")); } // Add the trust decision of the application to the fusion store. if (m_storeBounded) { CommitApplicationTrust(trust.ApplicationIdentity, trust.ToXml().ToString()); return(-1); } else { return(AppTrusts.Add(trust)); } }
/// <summary>创建 <see cref="T:System.Security.Policy.ApplicationTrust" /> 对象及其当前状态的 XML 编码。</summary> /// <returns>安全对象的 XML 编码,包括任何状态信息。</returns> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Read="*AllFiles*" PathDiscovery="*AllFiles*" /> /// <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="MemberAccess" /> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" /> /// </PermissionSet> public SecurityElement ToXml() { SecurityElement securityElement = new SecurityElement("ApplicationTrust"); securityElement.AddAttribute("version", "1"); if (this.m_appId != null) { securityElement.AddAttribute("FullName", SecurityElement.Escape(this.m_appId.FullName)); } if (this.m_appTrustedToRun) { securityElement.AddAttribute("TrustedToRun", "true"); } if (this.m_persist) { securityElement.AddAttribute("Persist", "true"); } if (this.m_psDefaultGrant != null) { SecurityElement child = new SecurityElement("DefaultGrant"); child.AddChild(this.m_psDefaultGrant.ToXml()); securityElement.AddChild(child); } if (this.m_fullTrustAssemblies.Count > 0) { SecurityElement child = new SecurityElement("FullTrustAssemblies"); foreach (StrongName fullTrustAssembly in (IEnumerable <StrongName>) this.m_fullTrustAssemblies) { child.AddChild(fullTrustAssembly.ToXml()); } securityElement.AddChild(child); } if (this.ExtraInfo != null) { securityElement.AddChild(ApplicationTrust.ObjectToXml("ExtraInfo", this.ExtraInfo)); } return(securityElement); }
public CommitApplicationParams(CommitApplicationParams src) { this.TimeStamp = DateTime.MinValue; this.AppId = src.AppId; this.CommitApp = src.CommitApp; this.AppManifest = src.AppManifest; this.AppSourceUri = src.AppSourceUri; this.AppManifestPath = src.AppManifestPath; this.AppPayloadPath = src.AppPayloadPath; this.AppGroup = src.AppGroup; this.CommitDeploy = src.CommitDeploy; this.DeployManifest = src.DeployManifest; this.DeploySourceUri = src.DeploySourceUri; this.DeployManifestPath = src.DeployManifestPath; this.TimeStamp = src.TimeStamp; this.IsConfirmed = src.IsConfirmed; this.IsUpdate = src.IsUpdate; this.IsRequiredUpdate = src.IsRequiredUpdate; this.IsUpdateInPKTGroup = src.IsUpdateInPKTGroup; this.IsFullTrustRequested = src.IsFullTrustRequested; this.appType = src.appType; this.Trust = src.Trust; }
public void AddRange(ApplicationTrust[] trusts) { if (trusts == null) { throw new ArgumentNullException("trusts"); } int index = 0; try { while (index < trusts.Length) { this.Add(trusts[index]); index++; } } catch { for (int i = 0; i < index; i++) { this.Remove(trusts[i]); } throw; } }
public void CopyTo (ApplicationTrust[] array, int index) { ((ICollection)this).CopyTo(array, index); }
public void ApplicationIdentity_Change () { ApplicationTrust at = new ApplicationTrust (); at.ApplicationIdentity = new ApplicationIdentity ("Mono Unit Test"); // ... but it can be changed at.ApplicationIdentity = new ApplicationIdentity ("Mono Unit Test Too"); }
public void Remove(ApplicationTrust trust) { throw new NotImplementedException(); }
public void FromXml_NoVersion () { ApplicationTrust at = new ApplicationTrust (); SecurityElement se = at.ToXml (); SecurityElement w = new SecurityElement (se.Tag); foreach (SecurityElement child in se.Children) w.AddChild (child); at.FromXml (w); }
public void FromXml_InvalidTag () { ApplicationTrust at = new ApplicationTrust (); SecurityElement se = at.ToXml (); se.Tag = "MonoTrust"; at.FromXml (se); }
public void ToFromXmlRoundtrip () { ApplicationTrust at = new ApplicationTrust (); at.ApplicationIdentity = new ApplicationIdentity ("Mono Unit Test"); at.DefaultGrantSet = new PolicyStatement (new PermissionSet (PermissionState.Unrestricted)); at.ExtraInfo = "Mono"; at.IsApplicationTrustedToRun = true; at.Persist = true; SecurityElement se = at.ToXml (); string expected = AdjustLineEnds ("<ApplicationTrust version=\"1\"\r\nFullName=\"Mono Unit Test, Culture=neutral\"\r\nTrustedToRun=\"true\"\r\nPersist=\"true\">\r\n<DefaultGrant>\r\n<PolicyStatement version=\"1\">\r\n<PermissionSet class=\"System.Security.PermissionSet\"\r\nversion=\"1\"\r\nUnrestricted=\"true\"/>\r\n</PolicyStatement>\r\n</DefaultGrant>\r\n<ExtraInfo Data=\"0001000000FFFFFFFF01000000000000000601000000044D6F6E6F0B\"/>\r\n</ApplicationTrust>\r\n"); Assert.AreEqual (expected, AdjustLineEnds (at.ToXml ().ToString ()), "XML"); ApplicationTrust copy = new ApplicationTrust (); copy.FromXml (se); se = copy.ToXml (); Assert.AreEqual (expected, AdjustLineEnds (at.ToXml ().ToString ()), "Copy"); }
private static ApplicationTrust CreateApplicationTrust(ActivationContext activationContext, ApplicationSecurityInfo info, ApplicationTrustExtraInfo appTrustExtraInfo, bool trust, bool persist) { ApplicationTrust appTrust = new ApplicationTrust(activationContext.Identity); appTrust.ExtraInfo = appTrustExtraInfo; appTrust.IsApplicationTrustedToRun = trust; appTrust.DefaultGrantSet = new PolicyStatement(info.DefaultRequestSet, (PolicyStatementAttribute) 0); appTrust.Persist = persist; return appTrust; }
public void Remove(ApplicationTrust trust) { }
public int Add(ApplicationTrust trust) { return(0); }
public void ExtraInfo_NotSerializable () { ApplicationTrust at = new ApplicationTrust (); at.ExtraInfo = this; SecurityElement se = at.ToXml (); }
public void Persist () { ApplicationTrust at = new ApplicationTrust (); at.Persist = true; Assert.IsTrue (at.Persist, "true"); string expected = AdjustLineEnds ("<ApplicationTrust version=\"1\"\r\nPersist=\"true\">\r\n<DefaultGrant>\r\n<PolicyStatement version=\"1\">\r\n<PermissionSet class=\"System.Security.PermissionSet\"\r\nversion=\"1\"/>\r\n</PolicyStatement>\r\n</DefaultGrant>\r\n</ApplicationTrust>\r\n"); Assert.AreEqual (expected, AdjustLineEnds (at.ToXml ().ToString ()), "XML"); at.Persist = false; Assert.IsFalse (at.Persist, "false"); }
// // Internal // internal static ApplicationTrust DetermineApplicationTrustInternal (ActivationContext activationContext, TrustManagerContext context) { ApplicationTrust trust = null; ApplicationTrustCollection userTrusts = new ApplicationTrustCollection(true); // See if there is a persisted trust decision for this application. if ((context == null || !context.IgnorePersistedDecision)) { trust = userTrusts[activationContext.Identity.FullName]; if (trust != null) return trust; } // There is no cached trust decision so invoke the trust manager. trust = ApplicationTrustManager.DetermineApplicationTrust(activationContext, context); if (trust == null) trust = new ApplicationTrust(activationContext.Identity); // make sure the application identity is correctly set. trust.ApplicationIdentity = activationContext.Identity; if (trust.Persist) userTrusts.Add(trust); return trust; }
public void FromXml_Null () { ApplicationTrust at = new ApplicationTrust (); at.FromXml (null); }
private void SetupDomainSecurityForApplication(System.ApplicationIdentity appIdentity, System.Security.Policy.ApplicationTrust appTrust) { this._applicationIdentity = appIdentity; this._applicationTrust = appTrust; nSetSecurityHomogeneousFlag(); }
public void FromXml_InvalidVersion () { ApplicationTrust at = new ApplicationTrust (); SecurityElement se = at.ToXml (); SecurityElement w = new SecurityElement (se.Tag); w.AddAttribute ("version", "2"); foreach (SecurityElement child in se.Children) w.AddChild (child); at.FromXml (w); }
[System.Security.SecurityCritical] // auto-generated private void SetupDomainSecurityForApplication(ApplicationIdentity appIdentity, ApplicationTrust appTrust) { // Set the Application trust on the managed side. _applicationIdentity = appIdentity; SetupDomainSecurityForHomogeneousDomain(appTrust, false); }
public void FromXml_NoChild () { ApplicationTrust at = new ApplicationTrust (); SecurityElement se = at.ToXml (); SecurityElement w = new SecurityElement (se.Tag); w.AddAttribute ("version", "1"); at.FromXml (w); Assert.IsNull (at.ApplicationIdentity, "ApplicationIdentity"); Assert.AreEqual (PolicyStatementAttribute.Nothing, at.DefaultGrantSet.Attributes, "DefaultGrantSet.Attributes"); Assert.AreEqual (String.Empty, at.DefaultGrantSet.AttributeString, "DefaultGrantSet.AttributeString"); Assert.IsTrue (at.DefaultGrantSet.PermissionSet.IsEmpty (), "DefaultGrantSet.PermissionSet.IsEmpty"); Assert.IsFalse (at.DefaultGrantSet.PermissionSet.IsUnrestricted (), "DefaultGrantSet.PermissionSet.IsUnrestricted"); Assert.IsNull (at.ExtraInfo, "ExtraInfo"); Assert.IsFalse (at.IsApplicationTrustedToRun, "IsApplicationTrustedToRun"); Assert.IsFalse (at.Persist, "Persist"); }
[System.Security.SecurityCritical] // auto-generated private void SetupDomainSecurityForHomogeneousDomain(ApplicationTrust appTrust, bool runtimeSuppliedHomogenousGrantSet) { // If the CLR has supplied the homogenous grant set (that is, this domain would have been // heterogenous in v2.0), then we need to strip the ApplicationTrust from the AppDomainSetup of // the current domain. This prevents code which does: // AppDomain.CreateDomain(..., AppDomain.CurrentDomain.SetupInformation); // // From looking like it is trying to create a homogenous domain intentionally, and therefore // having its evidence check bypassed. if (runtimeSuppliedHomogenousGrantSet) { BCLDebug.Assert(_FusionStore.ApplicationTrust != null, "Expected to find runtime supplied ApplicationTrust"); #if FEATURE_CAS_POLICY _FusionStore.ApplicationTrust = null; #endif // FEATURE_CAS_POLICY } _applicationTrust = appTrust; // Set the homogeneous bit in the VM's ApplicationSecurityDescriptor. SetSecurityHomogeneousFlag(GetNativeHandle(), runtimeSuppliedHomogenousGrantSet); }
public void Constructor_Null () { ApplicationTrust at = new ApplicationTrust (null); }
public void DefaultGrantSet () { ApplicationTrust at = new ApplicationTrust (); at.DefaultGrantSet = new PolicyStatement (new PermissionSet (PermissionState.Unrestricted)); Assert.IsNotNull (at.DefaultGrantSet, "not null"); string expected = AdjustLineEnds ("<ApplicationTrust version=\"1\">\r\n<DefaultGrant>\r\n<PolicyStatement version=\"1\">\r\n<PermissionSet class=\"System.Security.PermissionSet\"\r\nversion=\"1\"\r\nUnrestricted=\"true\"/>\r\n</PolicyStatement>\r\n</DefaultGrant>\r\n</ApplicationTrust>\r\n"); Assert.AreEqual (expected, AdjustLineEnds (at.ToXml ().ToString ()), "XML"); at.DefaultGrantSet = null; // returns to defaults Assert.IsNotNull (at.DefaultGrantSet, "null"); Assert.AreEqual (PolicyStatementAttribute.Nothing, at.DefaultGrantSet.Attributes, "DefaultGrantSet.Attributes"); Assert.AreEqual (String.Empty, at.DefaultGrantSet.AttributeString, "DefaultGrantSet.AttributeString"); Assert.IsTrue (at.DefaultGrantSet.PermissionSet.IsEmpty (), "DefaultGrantSet.PermissionSet.IsEmpty"); Assert.IsFalse (at.DefaultGrantSet.PermissionSet.IsUnrestricted (), "DefaultGrantSet.PermissionSet.IsUnrestricted"); }
public int Add(ApplicationTrust trust) { throw new NotImplementedException(); }
public void ExtraInfo () { ApplicationTrust at = new ApplicationTrust (); at.ExtraInfo = "Mono"; Assert.IsNotNull (at.ExtraInfo, "not null"); string expected = AdjustLineEnds ("<ApplicationTrust version=\"1\">\r\n<DefaultGrant>\r\n<PolicyStatement version=\"1\">\r\n<PermissionSet class=\"System.Security.PermissionSet\"\r\nversion=\"1\"/>\r\n</PolicyStatement>\r\n</DefaultGrant>\r\n<ExtraInfo Data=\"0001000000FFFFFFFF01000000000000000601000000044D6F6E6F0B\"/>\r\n</ApplicationTrust>\r\n"); Assert.AreEqual (expected, AdjustLineEnds (at.ToXml ().ToString ()), "XML"); at.ExtraInfo = null; Assert.IsNull (at.ExtraInfo, "null"); }
internal static ApplicationTrust DetermineApplicationTrustInternal(ActivationContext activationContext, TrustManagerContext context) { ApplicationTrust trust = null; ApplicationTrustCollection trusts = new ApplicationTrustCollection(true); if ((context == null) || !context.IgnorePersistedDecision) { trust = trusts[activationContext.Identity.FullName]; if (trust != null) { return trust; } } trust = ApplicationTrustManager.DetermineApplicationTrust(activationContext, context); if (trust == null) { trust = new ApplicationTrust(activationContext.Identity); } trust.ApplicationIdentity = activationContext.Identity; if (trust.Persist) { trusts.Add(trust); } return trust; }
[System.Security.SecurityCritical] // auto-generated public void RemoveRange (ApplicationTrust[] trusts) { if (trusts == null) throw new ArgumentNullException("trusts"); Contract.EndContractBlock(); int i=0; try { for (; i<trusts.Length; i++) { Remove(trusts[i]); } } catch { for (int j=0; j<i; j++) { Add(trusts[j]); } throw; } }