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 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 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;
}
}
