public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.PublisherIdentityPermission");
if (m_unrestricted)
{
esd.AddAttribute("Unrestricted", "true");
}
else if (m_certs != null)
{
if (m_certs.Length == 1)
{
esd.AddAttribute("X509v3Certificate", m_certs[0].GetRawCertDataString());
}
else
{
int n;
for (n = 0; n < m_certs.Length; n++)
{
SecurityElement child = new SecurityElement("Cert");
child.AddAttribute("X509v3Certificate", m_certs[n].GetRawCertDataString());
esd.AddChild(child);
}
}
}
return(esd);
}
/// <summary>Creates an XML encoding of the permission and its current state.</summary>
/// <returns>An XML encoding of the permission, including any state information. </returns>
// Token: 0x06002674 RID: 9844 RVA: 0x0008B6B0 File Offset: 0x000898B0
public override SecurityElement ToXml()
{
SecurityElement securityElement = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.UrlIdentityPermission");
if (this.m_unrestricted)
{
securityElement.AddAttribute("Unrestricted", "true");
}
else if (this.m_urls != null)
{
if (this.m_urls.Length == 1)
{
securityElement.AddAttribute("Url", this.m_urls[0].ToString());
}
else
{
for (int i = 0; i < this.m_urls.Length; i++)
{
SecurityElement securityElement2 = new SecurityElement("Url");
securityElement2.AddAttribute("Url", this.m_urls[i].ToString());
securityElement.AddChild(securityElement2);
}
}
}
return(securityElement);
}
public override SecurityElement ToXml()
{
SecurityElement element = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.SiteIdentityPermission");
if (this.m_unrestricted)
{
element.AddAttribute("Unrestricted", "true");
return(element);
}
if (this.m_sites != null)
{
if (this.m_sites.Length == 1)
{
element.AddAttribute("Site", this.m_sites[0].ToString());
return(element);
}
for (int i = 0; i < this.m_sites.Length; i++)
{
SecurityElement child = new SecurityElement("Site");
child.AddAttribute("Site", this.m_sites[i].ToString());
element.AddChild(child);
}
}
return(element);
}
/// <include file='doc\RegistryPermission.uex' path='docs/doc[@for="RegistryPermission.ToXml"]/*' />
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this);
if (!IsUnrestricted())
{
if (this.m_read != null && !this.m_read.IsEmpty())
{
esd.AddAttribute("Read", SecurityElement.Escape(m_read.ToString()));
}
if (this.m_write != null && !this.m_write.IsEmpty())
{
esd.AddAttribute("Write", SecurityElement.Escape(m_write.ToString()));
}
if (this.m_create != null && !this.m_create.IsEmpty())
{
esd.AddAttribute("Create", SecurityElement.Escape(m_create.ToString()));
}
}
else
{
esd.AddAttribute("Unrestricted", "true");
}
return(esd);
}
public override SecurityElement ToXml()
{
// SafeCritical: our string expression sets don't contain paths, so there's no information that
// needs to be guarded in them.
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.RegistryPermission");
if (!IsUnrestricted())
{
if (this.m_read != null && !this.m_read.IsEmpty())
{
esd.AddAttribute("Read", SecurityElement.Escape(m_read.UnsafeToString()));
}
if (this.m_write != null && !this.m_write.IsEmpty())
{
esd.AddAttribute("Write", SecurityElement.Escape(m_write.UnsafeToString()));
}
if (this.m_create != null && !this.m_create.IsEmpty())
{
esd.AddAttribute("Create", SecurityElement.Escape(m_create.UnsafeToString()));
}
if (this.m_viewAcl != null && !this.m_viewAcl.IsEmpty())
{
esd.AddAttribute("ViewAccessControl", SecurityElement.Escape(m_viewAcl.UnsafeToString()));
}
if (this.m_changeAcl != null && !this.m_changeAcl.IsEmpty())
{
esd.AddAttribute("ChangeAccessControl", SecurityElement.Escape(m_changeAcl.UnsafeToString()));
}
}
else
{
esd.AddAttribute("Unrestricted", "true");
}
return(esd);
}
// Token: 0x0600252A RID: 9514 RVA: 0x00087368 File Offset: 0x00085568
internal SecurityElement ToXml(string permName)
{
SecurityElement securityElement = CodeAccessPermission.CreatePermissionElement(this, permName);
if (!this.IsUnrestricted())
{
securityElement.AddAttribute("Allowed", Enum.GetName(typeof(IsolatedStorageContainment), this.m_allowed));
if (this.m_userQuota > 0L)
{
securityElement.AddAttribute("UserQuota", this.m_userQuota.ToString(CultureInfo.InvariantCulture));
}
if (this.m_machineQuota > 0L)
{
securityElement.AddAttribute("MachineQuota", this.m_machineQuota.ToString(CultureInfo.InvariantCulture));
}
if (this.m_expirationDays > 0L)
{
securityElement.AddAttribute("Expiry", this.m_expirationDays.ToString(CultureInfo.InvariantCulture));
}
if (this.m_permanentData)
{
securityElement.AddAttribute("Permanent", this.m_permanentData.ToString());
}
}
else
{
securityElement.AddAttribute("Unrestricted", "true");
}
return(securityElement);
}
public override SecurityElement ToXml()
{
SecurityElement securityElement = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.KeyContainerPermission");
if (!IsUnrestricted())
{
securityElement.AddAttribute("Flags", m_flags.ToString());
if (AccessEntries.Count > 0)
{
SecurityElement al = new SecurityElement("AccessList");
foreach (KeyContainerPermissionAccessEntry accessEntry in AccessEntries)
{
SecurityElement entryElem = new SecurityElement("AccessEntry");
entryElem.AddAttribute("KeyStore", accessEntry.KeyStore);
entryElem.AddAttribute("ProviderName", accessEntry.ProviderName);
entryElem.AddAttribute("ProviderType", accessEntry.ProviderType.ToString(null, null));
entryElem.AddAttribute("KeyContainerName", accessEntry.KeyContainerName);
entryElem.AddAttribute("KeySpec", accessEntry.KeySpec.ToString(null, null));
entryElem.AddAttribute("Flags", accessEntry.Flags.ToString());
al.AddChild(entryElem);
}
securityElement.AddChild(al);
}
}
else
{
securityElement.AddAttribute("Unrestricted", "true");
}
return(securityElement);
}
public override SecurityElement ToXml()
{
SecurityElement element = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.PublisherIdentityPermission");
if (this.m_unrestricted)
{
element.AddAttribute("Unrestricted", "true");
return(element);
}
if (this.m_certs != null)
{
if (this.m_certs.Length == 1)
{
element.AddAttribute("X509v3Certificate", this.m_certs[0].GetRawCertDataString());
return(element);
}
for (int i = 0; i < this.m_certs.Length; i++)
{
SecurityElement child = new SecurityElement("Cert");
child.AddAttribute("X509v3Certificate", this.m_certs[i].GetRawCertDataString());
element.AddChild(child);
}
}
return(element);
}
public override SecurityElement ToXml()
{
SecurityElement element = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.KeyContainerPermission");
if (!this.IsUnrestricted())
{
element.AddAttribute("Flags", this.m_flags.ToString());
if (this.AccessEntries.Count > 0)
{
SecurityElement child = new SecurityElement("AccessList");
KeyContainerPermissionAccessEntryEnumerator enumerator = this.AccessEntries.GetEnumerator();
while (enumerator.MoveNext())
{
KeyContainerPermissionAccessEntry current = enumerator.Current;
SecurityElement element3 = new SecurityElement("AccessEntry");
element3.AddAttribute("KeyStore", current.KeyStore);
element3.AddAttribute("ProviderName", current.ProviderName);
element3.AddAttribute("ProviderType", current.ProviderType.ToString(null, null));
element3.AddAttribute("KeyContainerName", current.KeyContainerName);
element3.AddAttribute("KeySpec", current.KeySpec.ToString(null, null));
element3.AddAttribute("Flags", current.Flags.ToString());
child.AddChild(element3);
}
element.AddChild(child);
}
return(element);
}
element.AddAttribute("Unrestricted", "true");
return(element);
}
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.SiteIdentityPermission");
if (m_unrestricted)
{
esd.AddAttribute("Unrestricted", "true");
}
else if (m_sites != null)
{
if (m_sites.Length == 1)
{
esd.AddAttribute("Site", m_sites[0].ToString());
}
else
{
int n;
for (n = 0; n < m_sites.Length; n++)
{
SecurityElement child = new SecurityElement("Site");
child.AddAttribute("Site", m_sites[n].ToString());
esd.AddChild(child);
}
}
}
return(esd);
}
/// <summary>创建权限及其当前状态的 XML 编码。</summary>
/// <returns>权限的 XML 编码，包括任何状态信息。</returns>
public override SecurityElement ToXml()
{
SecurityElement permissionElement = CodeAccessPermission.CreatePermissionElement((IPermission)this, "System.Security.Permissions.UrlIdentityPermission");
if (this.m_unrestricted)
{
permissionElement.AddAttribute("Unrestricted", "true");
}
else if (this.m_urls != null)
{
if (this.m_urls.Length == 1)
{
permissionElement.AddAttribute("Url", this.m_urls[0].ToString());
}
else
{
for (int index = 0; index < this.m_urls.Length; ++index)
{
SecurityElement child = new SecurityElement("Url");
child.AddAttribute("Url", this.m_urls[index].ToString());
permissionElement.AddChild(child);
}
}
}
return(permissionElement);
}
public override SecurityElement ToXml()
{
SecurityElement securityElement = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.RegistryPermission");
if (!this.IsUnrestricted())
{
if (this.m_read != null && !this.m_read.IsEmpty())
{
securityElement.AddAttribute("Read", SecurityElement.Escape(this.m_read.UnsafeToString()));
}
if (this.m_write != null && !this.m_write.IsEmpty())
{
securityElement.AddAttribute("Write", SecurityElement.Escape(this.m_write.UnsafeToString()));
}
if (this.m_create != null && !this.m_create.IsEmpty())
{
securityElement.AddAttribute("Create", SecurityElement.Escape(this.m_create.UnsafeToString()));
}
if (this.m_viewAcl != null && !this.m_viewAcl.IsEmpty())
{
securityElement.AddAttribute("ViewAccessControl", SecurityElement.Escape(this.m_viewAcl.UnsafeToString()));
}
if (this.m_changeAcl != null && !this.m_changeAcl.IsEmpty())
{
securityElement.AddAttribute("ChangeAccessControl", SecurityElement.Escape(this.m_changeAcl.UnsafeToString()));
}
}
else
{
securityElement.AddAttribute("Unrestricted", "true");
}
return(securityElement);
}
internal SecurityElement ToXml(String permName)
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, permName);
if (!IsUnrestricted())
{
esd.AddAttribute("Allowed", Enum.GetName(typeof(IsolatedStorageContainment), m_allowed));
if (m_userQuota > 0)
{
esd.AddAttribute(_strUserQuota, (m_userQuota).ToString(CultureInfo.InvariantCulture));
}
if (m_machineQuota > 0)
{
esd.AddAttribute(_strMachineQuota, (m_machineQuota).ToString(CultureInfo.InvariantCulture));
}
if (m_expirationDays > 0)
{
esd.AddAttribute(_strExpiry, (m_expirationDays).ToString(CultureInfo.InvariantCulture));
}
if (m_permanentData)
{
esd.AddAttribute(_strPermDat, (m_permanentData).ToString());
}
}
else
{
esd.AddAttribute("Unrestricted", "true");
}
return(esd);
}
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.ZoneIdentityPermission");
if (SecurityZone != SecurityZone.NoZone)
{
esd.AddAttribute("Zone", Enum.GetName(typeof(SecurityZone), this.SecurityZone));
}
else
{
int nEnum = 0;
uint nFlag;
for (nFlag = 1; nFlag < AllZones; nFlag <<= 1)
{
if ((m_zones & nFlag) != 0)
{
SecurityElement child = new SecurityElement("Zone");
child.AddAttribute("Zone", Enum.GetName(typeof(SecurityZone), (SecurityZone)nEnum));
esd.AddChild(child);
}
nEnum++;
}
}
return(esd);
}
//------------------------------------------------------
//
// XML
//
//------------------------------------------------------
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, this.GetType().FullName );
if(IsUnrestricted())
esd.AddAttribute( "Unrestricted", "true" );
else
esd.AddAttribute( "Resources", XMLUtil.BitFieldEnumToString( typeof( HostProtectionResource ), Resources ) );
return esd;
}
/// <include file='doc\PublisherIdentityPermission.uex' path='docs/doc[@for="PublisherIdentityPermission.ToXml"]/*' />
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this);
if (m_certificate != null)
{
esd.AddAttribute("X509v3Certificate", m_certificate.GetRawCertDataString());
}
return(esd);
}
/// <include file='doc\URLIdentityPermission.uex' path='docs/doc[@for="UrlIdentityPermission.ToXml"]/*' />
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this);
if (m_url != null)
{
esd.AddAttribute("Url", m_url.ToString());
}
return(esd);
}
/// <include file='doc\ZoneIdentityPermission.uex' path='docs/doc[@for="ZoneIdentityPermission.ToXml"]/*' />
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this);
if (m_zone != SecurityZone.NoZone)
{
esd.AddAttribute("Zone", Enum.GetName(typeof(SecurityZone), this.m_zone));
}
return(esd);
}
public override SecurityElement ToXml()
{
SecurityElement element = CodeAccessPermission.CreatePermissionElement(this, base.GetType().FullName);
if (this.IsUnrestricted())
{
element.AddAttribute("Unrestricted", "true");
return(element);
}
element.AddAttribute("Resources", XMLUtil.BitFieldEnumToString(typeof(HostProtectionResource), this.Resources));
return(element);
}
public override SecurityElement ToXml()
{
SecurityElement element = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.SecurityPermission");
if (!this.IsUnrestricted())
{
element.AddAttribute("Flags", XMLUtil.BitFieldEnumToString(typeof(SecurityPermissionFlag), this.m_flags));
return(element);
}
element.AddAttribute("Unrestricted", "true");
return(element);
}
/// <include file='doc\SecurityPermission.uex' path='docs/doc[@for="SecurityPermission.ToXml"]/*' />
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this);
if (!IsUnrestricted())
{
esd.AddAttribute("Flags", XMLUtil.BitFieldEnumToString(typeof(SecurityPermissionFlag), m_flags));
}
else
{
esd.AddAttribute("Unrestricted", "true");
}
return(esd);
}
/// <summary>创建权限及其当前状态的 XML 编码。</summary>
/// <returns>权限的 XML 编码，包括任何状态信息。</returns>
public override SecurityElement ToXml()
{
SecurityElement permissionElement = CodeAccessPermission.CreatePermissionElement((IPermission)this, "System.Security.Permissions.ReflectionPermission");
if (!this.IsUnrestricted())
{
permissionElement.AddAttribute("Flags", XMLUtil.BitFieldEnumToString(typeof(ReflectionPermissionFlag), (object)this.m_flags));
}
else
{
permissionElement.AddAttribute("Unrestricted", "true");
}
return(permissionElement);
}
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.StrongNameIdentityPermission");
if (m_unrestricted)
{
esd.AddAttribute("Unrestricted", "true");
}
else if (m_strongNames != null)
{
if (m_strongNames.Length == 1)
{
if (m_strongNames[0].m_publicKeyBlob != null)
{
esd.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(m_strongNames[0].m_publicKeyBlob.PublicKey));
}
if (m_strongNames[0].m_name != null)
{
esd.AddAttribute("Name", m_strongNames[0].m_name);
}
if ((Object)m_strongNames[0].m_version != null)
{
esd.AddAttribute("AssemblyVersion", m_strongNames[0].m_version.ToString());
}
}
else
{
int n;
for (n = 0; n < m_strongNames.Length; n++)
{
SecurityElement child = new SecurityElement("StrongName");
if (m_strongNames[n].m_publicKeyBlob != null)
{
child.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(m_strongNames[n].m_publicKeyBlob.PublicKey));
}
if (m_strongNames[n].m_name != null)
{
child.AddAttribute("Name", m_strongNames[n].m_name);
}
if ((Object)m_strongNames[n].m_version != null)
{
child.AddAttribute("AssemblyVersion", m_strongNames[n].m_version.ToString());
}
esd.AddChild(child);
}
}
}
return(esd);
}
public override SecurityElement ToXml()
{
SecurityElement element = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.FileDialogPermission");
if (!this.IsUnrestricted())
{
if (this.access != FileDialogPermissionAccess.None)
{
element.AddAttribute("Access", Enum.GetName(typeof(FileDialogPermissionAccess), this.access));
}
return(element);
}
element.AddAttribute("Unrestricted", "true");
return(element);
}
/// <summary>Creates an XML encoding of the permission and its current state.</summary>
/// <returns>An XML encoding of the permission, including any state information.</returns>
// Token: 0x06002645 RID: 9797 RVA: 0x0008A914 File Offset: 0x00088B14
public override SecurityElement ToXml()
{
SecurityElement securityElement = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.StrongNameIdentityPermission");
if (this.m_unrestricted)
{
securityElement.AddAttribute("Unrestricted", "true");
}
else if (this.m_strongNames != null)
{
if (this.m_strongNames.Length == 1)
{
if (this.m_strongNames[0].m_publicKeyBlob != null)
{
securityElement.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(this.m_strongNames[0].m_publicKeyBlob.PublicKey));
}
if (this.m_strongNames[0].m_name != null)
{
securityElement.AddAttribute("Name", this.m_strongNames[0].m_name);
}
if (this.m_strongNames[0].m_version != null)
{
securityElement.AddAttribute("AssemblyVersion", this.m_strongNames[0].m_version.ToString());
}
}
else
{
for (int i = 0; i < this.m_strongNames.Length; i++)
{
SecurityElement securityElement2 = new SecurityElement("StrongName");
if (this.m_strongNames[i].m_publicKeyBlob != null)
{
securityElement2.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(this.m_strongNames[i].m_publicKeyBlob.PublicKey));
}
if (this.m_strongNames[i].m_name != null)
{
securityElement2.AddAttribute("Name", this.m_strongNames[i].m_name);
}
if (this.m_strongNames[i].m_version != null)
{
securityElement2.AddAttribute("AssemblyVersion", this.m_strongNames[i].m_version.ToString());
}
securityElement.AddChild(securityElement2);
}
}
}
return(securityElement);
}
/// <include file='doc\FileDialogPermission.uex' path='docs/doc[@for="FileDialogPermission.ToXml"]/*' />
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this);
if (!IsUnrestricted())
{
if (access != FileDialogPermissionAccess.None)
{
esd.AddAttribute("Access", Enum.GetName(typeof(FileDialogPermissionAccess), access));
}
}
else
{
esd.AddAttribute("Unrestricted", "true");
}
return(esd);
}
public override SecurityElement ToXml()
{
SecurityElement element = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.UIPermission");
if (!this.IsUnrestricted())
{
if (this.m_windowFlag != UIPermissionWindow.NoWindows)
{
element.AddAttribute("Window", Enum.GetName(typeof(UIPermissionWindow), this.m_windowFlag));
}
if (this.m_clipboardFlag != UIPermissionClipboard.NoClipboard)
{
element.AddAttribute("Clipboard", Enum.GetName(typeof(UIPermissionClipboard), this.m_clipboardFlag));
}
return(element);
}
element.AddAttribute("Unrestricted", "true");
return(element);
}
public override SecurityElement ToXml()
{
SecurityElement element = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.EnvironmentPermission");
if (!this.IsUnrestricted())
{
if ((this.m_read != null) && !this.m_read.IsEmpty())
{
element.AddAttribute("Read", SecurityElement.Escape(this.m_read.ToString()));
}
if ((this.m_write != null) && !this.m_write.IsEmpty())
{
element.AddAttribute("Write", SecurityElement.Escape(this.m_write.ToString()));
}
return(element);
}
element.AddAttribute("Unrestricted", "true");
return(element);
}
/// <include file='doc\StrongNameIdentityPermission.uex' path='docs/doc[@for="StrongNameIdentityPermission.ToXml"]/*' />
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this);
if (m_publicKeyBlob != null)
{
esd.AddAttribute("PublicKeyBlob", Hex.EncodeHexString(m_publicKeyBlob.PublicKey));
}
if (m_name != null)
{
esd.AddAttribute("Name", m_name);
}
if ((Object)m_version != null)
{
esd.AddAttribute("AssemblyVersion", m_version.ToString());
}
return(esd);
}
/// <include file='doc\UIPermission.uex' path='docs/doc[@for="UIPermission.ToXml"]/*' />
public override SecurityElement ToXml()
{
SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this);
if (!IsUnrestricted())
{
if (m_windowFlag != UIPermissionWindow.NoWindows)
{
esd.AddAttribute("Window", Enum.GetName(typeof(UIPermissionWindow), m_windowFlag));
}
if (m_clipboardFlag != UIPermissionClipboard.NoClipboard)
{
esd.AddAttribute("Clipboard", Enum.GetName(typeof(UIPermissionClipboard), m_clipboardFlag));
}
}
else
{
esd.AddAttribute("Unrestricted", "true");
}
return(esd);
}
