private void VerifyAccess(ReflectionPermissionFlag type)
{
if ((type & ~(ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.AllFlags)) != ReflectionPermissionFlag.NoFlags)
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int)type }));
}
}
// Convert an XML value into a permissions value.
public override void FromXml(SecurityElement esd)
{
String value;
if(esd == null)
{
throw new ArgumentNullException("esd");
}
if(esd.Attribute("version") != "1")
{
throw new ArgumentException(_("Arg_PermissionVersion"));
}
value = esd.Attribute("Unrestricted");
if(value != null && Boolean.Parse(value))
{
state = PermissionState.Unrestricted;
}
else
{
state = PermissionState.None;
}
value = esd.Attribute("Flags");
if(value != null)
{
flags = (ReflectionPermissionFlag)
Enum.Parse(typeof(ReflectionPermissionFlag), value);
}
else
{
flags = ReflectionPermissionFlag.NoFlags;
}
}
}// PutValuesinPage
internal override IPermission GetCurrentPermission()
{
ReflectionPermission refperm;
if (m_radUnrestricted.Checked == true)
{
refperm = new ReflectionPermission(PermissionState.Unrestricted);
}
else
{
ReflectionPermissionFlag rpf = ReflectionPermissionFlag.NoFlags;
if (m_chkMemberAccess.Checked == true)
{
rpf |= ReflectionPermissionFlag.MemberAccess;
}
if (m_chkReflectionEmit.Checked == true)
{
rpf |= ReflectionPermissionFlag.ReflectionEmit;
}
if (m_chkTypeInformation.Checked == true)
{
rpf |= ReflectionPermissionFlag.TypeInformation;
}
refperm = new ReflectionPermission(rpf);
}
return(refperm);
}// GetCurrentPermission
//
// IPermission implementation
//
public override IPermission Union(IPermission other)
{
if (other == null)
{
return(this.Copy());
}
else if (!VerifyType(other))
{
throw new
ArgumentException(
Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
);
}
ReflectionPermission operand = (ReflectionPermission)other;
if (this.IsUnrestricted() || operand.IsUnrestricted())
{
return(new ReflectionPermission(PermissionState.Unrestricted));
}
else
{
ReflectionPermissionFlag flag_union = (ReflectionPermissionFlag)(m_flags | operand.m_flags);
return(new ReflectionPermission(flag_union));
}
}
public override IPermission Intersect(IPermission target)
{
if (target == null)
{
return(null);
}
else if (!VerifyType(target))
{
throw new
ArgumentException(
Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
);
}
ReflectionPermission operand = (ReflectionPermission)target;
ReflectionPermissionFlag newFlags = operand.m_flags & this.m_flags;
if (newFlags == ReflectionPermissionFlag.NoFlags)
{
return(null);
}
else
{
return(new ReflectionPermission(newFlags));
}
}
public override void FromXml(SecurityElement esd)
{
// General validation in CodeAccessPermission
CheckSecurityElement(esd, "esd", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
if (IsUnrestricted(esd))
{
flags = ReflectionPermissionFlag.AllFlags;
}
else
{
flags = ReflectionPermissionFlag.NoFlags;
string xmlFlags = (esd.Attributes ["Flags"] as string);
if (xmlFlags.IndexOf("MemberAccess") >= 0)
{
flags |= ReflectionPermissionFlag.MemberAccess;
}
if (xmlFlags.IndexOf("ReflectionEmit") >= 0)
{
flags |= ReflectionPermissionFlag.ReflectionEmit;
}
if (xmlFlags.IndexOf("TypeInformation") >= 0)
{
flags |= ReflectionPermissionFlag.TypeInformation;
}
}
}
// Parameters:
//
public ReflectionPermission(ReflectionPermissionFlag flag)
{
VerifyAccess(flag);
SetUnrestricted(false);
m_flags = flag;
}
// Convert an XML value into a permissions value.
public override void FromXml(SecurityElement esd)
{
String value;
if (esd == null)
{
throw new ArgumentNullException("esd");
}
if (esd.Attribute("version") != "1")
{
throw new ArgumentException(_("Arg_PermissionVersion"));
}
value = esd.Attribute("Unrestricted");
if (value != null && Boolean.Parse(value))
{
state = PermissionState.Unrestricted;
}
else
{
state = PermissionState.None;
}
value = esd.Attribute("Flags");
if (value != null)
{
flags = (ReflectionPermissionFlag)
Enum.Parse(typeof(ReflectionPermissionFlag), value);
}
else
{
flags = ReflectionPermissionFlag.NoFlags;
}
}
void VerifyAccess(ReflectionPermissionFlag type)
{
if ((type & ~ReflectionPermissionFlag.AllFlags) != 0)
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)type));
}
}
public ReflectionPermission (PermissionState state)
{
if (CheckPermissionState (state, true) == PermissionState.Unrestricted)
flags = ReflectionPermissionFlag.AllFlags;
else
flags = ReflectionPermissionFlag.NoFlags;
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
if (CodeAccessPermission.IsUnrestricted(esd))
{
this.flags = ReflectionPermissionFlag.AllFlags;
}
else
{
this.flags = ReflectionPermissionFlag.NoFlags;
string text = esd.Attributes["Flags"] as string;
if (text.IndexOf("MemberAccess") >= 0)
{
this.flags |= ReflectionPermissionFlag.MemberAccess;
}
if (text.IndexOf("ReflectionEmit") >= 0)
{
this.flags |= ReflectionPermissionFlag.ReflectionEmit;
}
if (text.IndexOf("TypeInformation") >= 0)
{
this.flags |= ReflectionPermissionFlag.TypeInformation;
}
}
}
// Parameters:
//
public ReflectionPermission(ReflectionPermissionFlag flag)
{
VerifyAccess(flag);
SetUnrestricted(false);
m_flags = flag;
}
void VerifyAccess(ReflectionPermissionFlag type)
{
if ((type & ~ReflectionPermission.AllFlagsAndMore) != 0)
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)type));
}
Contract.EndContractBlock();
}
private void SetUnrestricted(bool unrestricted)
{
if (unrestricted)
{
this.m_flags = ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.AllFlags;
}
else
{
this.Reset();
}
}
//------------------------------------------------------
//
// PRIVATE AND PROTECTED MODIFIERS
//
//------------------------------------------------------
private void SetUnrestricted(bool unrestricted)
{
if (unrestricted)
{
m_flags = ReflectionPermission.AllFlagsAndMore;
}
else
{
Reset();
}
}
public ReflectionPermission(PermissionState state)
{
if (CheckPermissionState(state, true) == PermissionState.Unrestricted)
{
flags = ReflectionPermissionFlag.AllFlags;
}
else
{
flags = ReflectionPermissionFlag.NoFlags;
}
}
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Permissions.ReflectionPermission" /> class with either fully restricted or unrestricted permission as specified.</summary>
/// <param name="state">One of the <see cref="T:System.Security.Permissions.PermissionState" /> values. </param>
/// <exception cref="T:System.ArgumentException">The <paramref name="state" /> parameter is not a valid value of <see cref="T:System.Security.Permissions.PermissionState" />. </exception>
public ReflectionPermission(PermissionState state)
{
if (CodeAccessPermission.CheckPermissionState(state, true) == PermissionState.Unrestricted)
{
this.flags = ReflectionPermissionFlag.AllFlags;
}
else
{
this.flags = ReflectionPermissionFlag.NoFlags;
}
}
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.ValidateElement(esd, this);
if (XMLUtil.IsUnrestricted(esd))
{
this.m_flags = ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.AllFlags;
}
else
{
this.Reset();
this.SetUnrestricted(false);
string str = esd.Attribute("Flags");
if (str != null)
{
this.m_flags = (ReflectionPermissionFlag) Enum.Parse(typeof(ReflectionPermissionFlag), str);
}
}
}
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.ValidateElement(esd, this);
if (XMLUtil.IsUnrestricted(esd))
{
this.m_flags = ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.AllFlags;
}
else
{
this.Reset();
this.SetUnrestricted(false);
string str = esd.Attribute("Flags");
if (str != null)
{
this.m_flags = (ReflectionPermissionFlag)Enum.Parse(typeof(ReflectionPermissionFlag), str);
}
}
}
/// <summary>创建并返回一个权限，该权限是当前权限和指定权限的交集。</summary>
/// <returns>一个新权限，它表示当前权限与指定权限的交集。如果交集为空，则此新权限为 null。</returns>
/// <param name="target">要与当前权限相交的权限。它必须与当前权限属于同一类型。</param>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="target" /> 参数不是 null，而且与当前权限不是同一类型。</exception>
public override IPermission Intersect(IPermission target)
{
if (target == null)
{
return((IPermission)null);
}
if (!this.VerifyType(target))
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", (object)this.GetType().FullName));
}
ReflectionPermissionFlag flag = ((ReflectionPermission)target).m_flags & this.m_flags;
if (flag == ReflectionPermissionFlag.NoFlags)
{
return((IPermission)null);
}
return((IPermission) new ReflectionPermission(flag));
}
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.ValidateElement(esd, this);
if (XMLUtil.IsUnrestricted(esd))
{
m_flags = ReflectionPermission.AllFlagsAndMore;
return;
}
Reset();
SetUnrestricted(false);
String flags = esd.Attribute("Flags");
if (flags != null)
{
m_flags = (ReflectionPermissionFlag)Enum.Parse(typeof(ReflectionPermissionFlag), flags);
}
}
public override IPermission Intersect(IPermission target)
{
if (target == null)
{
return(null);
}
if (!base.VerifyType(target))
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName }));
}
ReflectionPermission permission = (ReflectionPermission)target;
ReflectionPermissionFlag flag = permission.m_flags & this.m_flags;
if (flag == ReflectionPermissionFlag.NoFlags)
{
return(null);
}
return(new ReflectionPermission(flag));
}
/// <summary>Creates a permission that is the union of the current permission and the specified permission.</summary>
/// <param name="other">A permission to combine with the current permission. It must be of the same type as the current permission. </param>
/// <returns>A new permission that represents the union of the current permission and the specified permission.</returns>
/// <exception cref="T:System.ArgumentException">The <paramref name="other" /> parameter is not <see langword="null" /> and is not of the same type as the current permission. </exception>
// Token: 0x060025F2 RID: 9714 RVA: 0x000887E0 File Offset: 0x000869E0
public override IPermission Union(IPermission other)
{
if (other == null)
{
return(this.Copy());
}
if (!base.VerifyType(other))
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[]
{
base.GetType().FullName
}));
}
ReflectionPermission reflectionPermission = (ReflectionPermission)other;
if (this.IsUnrestricted() || reflectionPermission.IsUnrestricted())
{
return(new ReflectionPermission(PermissionState.Unrestricted));
}
ReflectionPermissionFlag flag = this.m_flags | reflectionPermission.m_flags;
return(new ReflectionPermission(flag));
}
public ReflectionPermission(ReflectionPermissionFlag flag)
{
}
private static int MapToSpecialFlags(SecurityPermissionFlag securityPermissionFlags, ReflectionPermissionFlag reflectionPermissionFlags)
{
int num = 0;
if ((securityPermissionFlags & SecurityPermissionFlag.UnmanagedCode) == SecurityPermissionFlag.UnmanagedCode)
{
num |= 1;
}
if ((securityPermissionFlags & SecurityPermissionFlag.SkipVerification) == SecurityPermissionFlag.SkipVerification)
{
num |= 2;
}
if ((securityPermissionFlags & SecurityPermissionFlag.Assertion) == SecurityPermissionFlag.Assertion)
{
num |= 8;
}
if ((securityPermissionFlags & SecurityPermissionFlag.SerializationFormatter) == SecurityPermissionFlag.SerializationFormatter)
{
num |= 0x20;
}
if ((securityPermissionFlags & SecurityPermissionFlag.BindingRedirects) == SecurityPermissionFlag.BindingRedirects)
{
num |= 0x100;
}
if ((securityPermissionFlags & SecurityPermissionFlag.ControlEvidence) == SecurityPermissionFlag.ControlEvidence)
{
num |= 0x10000;
}
if ((securityPermissionFlags & SecurityPermissionFlag.ControlPrincipal) == SecurityPermissionFlag.ControlPrincipal)
{
num |= 0x20000;
}
if ((reflectionPermissionFlags & ReflectionPermissionFlag.RestrictedMemberAccess) == ReflectionPermissionFlag.RestrictedMemberAccess)
{
num |= 0x40;
}
if ((reflectionPermissionFlags & ReflectionPermissionFlag.MemberAccess) == ReflectionPermissionFlag.MemberAccess)
{
num |= 0x10;
}
return(num);
}
internal static int GetSpecialFlags(PermissionSet grantSet, PermissionSet deniedSet)
{
if ((grantSet != null && grantSet.IsUnrestricted()) && (deniedSet == null || deniedSet.IsEmpty()))
{
return(-1);
}
else
{
SecurityPermission securityPermission = null;
#pragma warning disable 618
SecurityPermissionFlag securityPermissionFlags = SecurityPermissionFlag.NoFlags;
#pragma warning restore 618
ReflectionPermission reflectionPermission = null;
ReflectionPermissionFlag reflectionPermissionFlags = ReflectionPermissionFlag.NoFlags;
CodeAccessPermission[] specialPermissions = new CodeAccessPermission[6];
if (grantSet != null)
{
if (grantSet.IsUnrestricted())
{
#pragma warning disable 618
securityPermissionFlags = SecurityPermissionFlag.AllFlags;
#pragma warning restore 618
reflectionPermissionFlags = ReflectionPermission.AllFlagsAndMore;
for (int i = 0; i < specialPermissions.Length; i++)
{
specialPermissions[i] = s_UnrestrictedSpecialPermissionMap[i];
}
}
else
{
securityPermission = grantSet.GetPermission(BuiltInPermissionIndex.SecurityPermissionIndex) as SecurityPermission;
if (securityPermission != null)
{
securityPermissionFlags = securityPermission.Flags;
}
reflectionPermission = grantSet.GetPermission(BuiltInPermissionIndex.ReflectionPermissionIndex) as ReflectionPermission;
if (reflectionPermission != null)
{
reflectionPermissionFlags = reflectionPermission.Flags;
}
for (int i = 0; i < specialPermissions.Length; i++)
{
specialPermissions[i] = grantSet.GetPermission(s_BuiltInPermissionIndexMap[i][0]) as CodeAccessPermission;
}
}
}
if (deniedSet != null)
{
if (deniedSet.IsUnrestricted())
{
#pragma warning disable 618
securityPermissionFlags = SecurityPermissionFlag.NoFlags;
#pragma warning restore 618
reflectionPermissionFlags = ReflectionPermissionFlag.NoFlags;
for (int i = 0; i < s_BuiltInPermissionIndexMap.Length; i++)
{
specialPermissions[i] = null;
}
}
else
{
securityPermission = deniedSet.GetPermission(BuiltInPermissionIndex.SecurityPermissionIndex) as SecurityPermission;
if (securityPermission != null)
{
securityPermissionFlags &= ~securityPermission.Flags;
}
reflectionPermission = deniedSet.GetPermission(BuiltInPermissionIndex.ReflectionPermissionIndex) as ReflectionPermission;
if (reflectionPermission != null)
{
reflectionPermissionFlags &= ~reflectionPermission.Flags;
}
for (int i = 0; i < s_BuiltInPermissionIndexMap.Length; i++)
{
CodeAccessPermission deniedSpecialPermission = deniedSet.GetPermission(s_BuiltInPermissionIndexMap[i][0]) as CodeAccessPermission;
if (deniedSpecialPermission != null && !deniedSpecialPermission.IsSubsetOf(null))
{
specialPermissions[i] = null; // we don't care about the exact value here.
}
}
}
}
int flags = MapToSpecialFlags(securityPermissionFlags, reflectionPermissionFlags);
if (flags != -1)
{
for (int i = 0; i < specialPermissions.Length; i++)
{
if (specialPermissions[i] != null && ((IUnrestrictedPermission)specialPermissions[i]).IsUnrestricted())
{
flags |= (1 << (int)s_BuiltInPermissionIndexMap[i][1]);
}
}
}
return(flags);
}
}
//------------------------------------------------------
//
// PRIVATE AND PROTECTED MODIFIERS
//
//------------------------------------------------------
private void SetUnrestricted(bool unrestricted)
{
if (unrestricted)
{
m_flags = ReflectionPermission.AllFlagsAndMore;
}
else
{
Reset();
}
}
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.ValidateElement( esd, this );
if (XMLUtil.IsUnrestricted( esd ))
{
m_flags = ReflectionPermission.AllFlagsAndMore;
return;
}
Reset () ;
SetUnrestricted (false) ;
String flags = esd.Attribute( "Flags" );
if (flags != null)
m_flags = (ReflectionPermissionFlag)Enum.Parse( typeof( ReflectionPermissionFlag ), flags );
}
private void Reset()
{
m_flags = ReflectionPermissionFlag.NoFlags;
}
public ReflectionPermission (ReflectionPermissionFlag flag)
{
// reuse validation by the Flags property
Flags = flag;
}
private void VerifyAccess(ReflectionPermissionFlag type)
{
if ((type & ~(ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.AllFlags)) != ReflectionPermissionFlag.NoFlags)
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int) type }));
}
}
public ReflectionPermission(ReflectionPermissionFlag flag)
{
return(default(ReflectionPermission));
}
private void BtSetOpt_Click(object sender, EventArgs e)
{
switch (LBOption.SelectedIndex)
{
case 0:
{
SecurityPermissionFlag flag = 0;
if (LBArg.SelectedIndex == 0 || LBArg.SelectedIndex == 1)
{
flag = (SecurityPermissionFlag)LBArg.SelectedIndex;
}
else
{
flag = (SecurityPermissionFlag)Math.Pow(2, LBArg.SelectedIndex - 1);
}
if (MessageBox.Show($"Sure to add parametr: {flag}", "Question", MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.Yes)
{
_secPerm.Flags = flag;
LBAddFlg.Items.Add((nameof(SecurityPermission) + ": " + flag + "."));
}
break;
}
case 1:
{
FileIOPermissionAccess flag = 0;
if (LBArg.SelectedIndex == 0)
{
flag = FileIOPermissionAccess.AllAccess;
}
else if (LBArg.SelectedIndex == 1 || LBArg.SelectedIndex == 2)
{
flag = (FileIOPermissionAccess)LBArg.SelectedIndex - 1;
}
else
{
flag = (FileIOPermissionAccess)Math.Pow(2, LBArg.SelectedIndex - 2);
}
if (MessageBox.Show($"Sure to add parametr: {flag}", "Question", MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.Yes)
{
_filePerm.AllLocalFiles = flag;
LBAddFlg.Items.Add((nameof(FileIOPermission) + ": " + flag + "."));
}
break;
}
case 2:
{
ReflectionPermissionFlag flag = 0;
if (LBArg.SelectedIndex == 0)
{
flag = ReflectionPermissionFlag.NoFlags;
}
else
{
flag = ReflectionPermissionFlag.MemberAccess;
}
if (MessageBox.Show($"Sure to add parametr: {flag}", "Question", MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.Yes)
{
_reflPerm.Flags = flag;
LBAddFlg.Items.Add((nameof(ReflectionPermission) + ": " + flag + "."));
}
break;
}
}
}
private static int MapToSpecialFlags(SecurityPermissionFlag securityPermissionFlags, ReflectionPermissionFlag reflectionPermissionFlags)
{
int num = 0;
if ((securityPermissionFlags & SecurityPermissionFlag.UnmanagedCode) == SecurityPermissionFlag.UnmanagedCode)
{
num |= 1;
}
if ((securityPermissionFlags & SecurityPermissionFlag.SkipVerification) == SecurityPermissionFlag.SkipVerification)
{
num |= 2;
}
if ((securityPermissionFlags & SecurityPermissionFlag.Assertion) == SecurityPermissionFlag.Assertion)
{
num |= 8;
}
if ((securityPermissionFlags & SecurityPermissionFlag.SerializationFormatter) == SecurityPermissionFlag.SerializationFormatter)
{
num |= 0x20;
}
if ((securityPermissionFlags & SecurityPermissionFlag.BindingRedirects) == SecurityPermissionFlag.BindingRedirects)
{
num |= 0x100;
}
if ((securityPermissionFlags & SecurityPermissionFlag.ControlEvidence) == SecurityPermissionFlag.ControlEvidence)
{
num |= 0x10000;
}
if ((securityPermissionFlags & SecurityPermissionFlag.ControlPrincipal) == SecurityPermissionFlag.ControlPrincipal)
{
num |= 0x20000;
}
if ((reflectionPermissionFlags & ReflectionPermissionFlag.RestrictedMemberAccess) == ReflectionPermissionFlag.RestrictedMemberAccess)
{
num |= 0x40;
}
if ((reflectionPermissionFlags & ReflectionPermissionFlag.MemberAccess) == ReflectionPermissionFlag.MemberAccess)
{
num |= 0x10;
}
return num;
}
internal static int GetSpecialFlags(PermissionSet grantSet, PermissionSet deniedSet)
{
if (((grantSet != null) && grantSet.IsUnrestricted()) && ((deniedSet == null) || deniedSet.IsEmpty()))
{
return(-1);
}
SecurityPermission permission = null;
SecurityPermissionFlag noFlags = SecurityPermissionFlag.NoFlags;
ReflectionPermission permission2 = null;
ReflectionPermissionFlag reflectionPermissionFlags = ReflectionPermissionFlag.NoFlags;
CodeAccessPermission[] permissionArray = new CodeAccessPermission[6];
if (grantSet != null)
{
if (grantSet.IsUnrestricted())
{
noFlags = SecurityPermissionFlag.AllFlags;
reflectionPermissionFlags = ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.AllFlags;
for (int i = 0; i < permissionArray.Length; i++)
{
permissionArray[i] = s_UnrestrictedSpecialPermissionMap[i];
}
}
else
{
permission = grantSet.GetPermission(6) as SecurityPermission;
if (permission != null)
{
noFlags = permission.Flags;
}
permission2 = grantSet.GetPermission(4) as ReflectionPermission;
if (permission2 != null)
{
reflectionPermissionFlags = permission2.Flags;
}
for (int j = 0; j < permissionArray.Length; j++)
{
permissionArray[j] = grantSet.GetPermission(s_BuiltInPermissionIndexMap[j][0]) as CodeAccessPermission;
}
}
}
if (deniedSet != null)
{
if (deniedSet.IsUnrestricted())
{
noFlags = SecurityPermissionFlag.NoFlags;
reflectionPermissionFlags = ReflectionPermissionFlag.NoFlags;
for (int k = 0; k < s_BuiltInPermissionIndexMap.Length; k++)
{
permissionArray[k] = null;
}
}
else
{
permission = deniedSet.GetPermission(6) as SecurityPermission;
if (permission != null)
{
noFlags &= ~permission.Flags;
}
permission2 = deniedSet.GetPermission(4) as ReflectionPermission;
if (permission2 != null)
{
reflectionPermissionFlags &= ~permission2.Flags;
}
for (int m = 0; m < s_BuiltInPermissionIndexMap.Length; m++)
{
CodeAccessPermission permission3 = deniedSet.GetPermission(s_BuiltInPermissionIndexMap[m][0]) as CodeAccessPermission;
if ((permission3 != null) && !permission3.IsSubsetOf(null))
{
permissionArray[m] = null;
}
}
}
}
int num5 = MapToSpecialFlags(noFlags, reflectionPermissionFlags);
if (num5 != -1)
{
for (int n = 0; n < permissionArray.Length; n++)
{
if ((permissionArray[n] != null) && ((IUnrestrictedPermission)permissionArray[n]).IsUnrestricted())
{
num5 |= ((int)1) << s_BuiltInPermissionIndexMap[n][1];
}
}
}
return(num5);
}
#pragma warning disable 618
private static int MapToSpecialFlags (SecurityPermissionFlag securityPermissionFlags, ReflectionPermissionFlag reflectionPermissionFlags) {
#pragma warning restore 618
int flags = 0;
#pragma warning disable 618
if ((securityPermissionFlags & SecurityPermissionFlag.UnmanagedCode) == SecurityPermissionFlag.UnmanagedCode)
#pragma warning restore 618
flags |= (1 << (int) PermissionType.SecurityUnmngdCodeAccess);
if ((securityPermissionFlags & SecurityPermissionFlag.SkipVerification) == SecurityPermissionFlag.SkipVerification)
flags |= (1 << (int) PermissionType.SecuritySkipVerification);
if ((securityPermissionFlags & SecurityPermissionFlag.Assertion) == SecurityPermissionFlag.Assertion)
flags |= (1 << (int) PermissionType.SecurityAssert);
if ((securityPermissionFlags & SecurityPermissionFlag.SerializationFormatter) == SecurityPermissionFlag.SerializationFormatter)
flags |= (1 << (int) PermissionType.SecuritySerialization);
if ((securityPermissionFlags & SecurityPermissionFlag.BindingRedirects) == SecurityPermissionFlag.BindingRedirects)
flags |= (1 << (int) PermissionType.SecurityBindingRedirects);
if ((securityPermissionFlags & SecurityPermissionFlag.ControlEvidence) == SecurityPermissionFlag.ControlEvidence)
flags |= (1 << (int) PermissionType.SecurityControlEvidence);
if ((securityPermissionFlags & SecurityPermissionFlag.ControlPrincipal) == SecurityPermissionFlag.ControlPrincipal)
flags |= (1 << (int) PermissionType.SecurityControlPrincipal);
if ((reflectionPermissionFlags & ReflectionPermissionFlag.RestrictedMemberAccess) == ReflectionPermissionFlag.RestrictedMemberAccess)
flags |= (1 << (int)PermissionType.ReflectionRestrictedMemberAccess);
if ((reflectionPermissionFlags & ReflectionPermissionFlag.MemberAccess) == ReflectionPermissionFlag.MemberAccess)
flags |= (1 << (int) PermissionType.ReflectionMemberAccess);
return flags;
}
void VerifyAccess(ReflectionPermissionFlag type)
{
if ((type & ~ReflectionPermissionFlag.AllFlags) != 0)
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)type));
}
private void SetUnrestricted(bool unrestricted)
{
if (unrestricted)
{
this.m_flags = ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.AllFlags;
}
else
{
this.Reset();
}
}
public override void FromXml (SecurityElement esd)
{
// General validation in CodeAccessPermission
CheckSecurityElement (esd, "esd", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
if (IsUnrestricted (esd)) {
flags = ReflectionPermissionFlag.AllFlags;
}
else {
flags = ReflectionPermissionFlag.NoFlags;
string xmlFlags = (esd.Attributes ["Flags"] as string);
if (xmlFlags.IndexOf ("MemberAccess") >= 0)
flags |= ReflectionPermissionFlag.MemberAccess;
if (xmlFlags.IndexOf ("ReflectionEmit") >= 0)
flags |= ReflectionPermissionFlag.ReflectionEmit;
if (xmlFlags.IndexOf ("TypeInformation") >= 0)
flags |= ReflectionPermissionFlag.TypeInformation;
}
}
private void Reset()
{
m_flags = ReflectionPermissionFlag.NoFlags;
}
void VerifyAccess(ReflectionPermissionFlag type)
{
if ((type & ~ReflectionPermission.AllFlagsAndMore) != 0)
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)type));
Contract.EndContractBlock();
}
public ReflectionPermission(ReflectionPermissionFlag flags)
{
this.flags = flags;
}
public ReflectionPermission(ReflectionPermissionFlag flag)
{
// reuse validation by the Flags property
Flags = flag;
}
public ReflectionPermission(ReflectionPermissionFlag flags)
{
this.flags = flags;
}
#pragma warning disable 618
private static int MapToSpecialFlags(SecurityPermissionFlag securityPermissionFlags, ReflectionPermissionFlag reflectionPermissionFlags)
{
int flags = 0;
if ((securityPermissionFlags & SecurityPermissionFlag.UnmanagedCode) == SecurityPermissionFlag.UnmanagedCode)
{
flags |= (1 << (int)PermissionType.SecurityUnmngdCodeAccess);
}
if ((securityPermissionFlags & SecurityPermissionFlag.SkipVerification) == SecurityPermissionFlag.SkipVerification)
{
flags |= (1 << (int)PermissionType.SecuritySkipVerification);
}
if ((securityPermissionFlags & SecurityPermissionFlag.Assertion) == SecurityPermissionFlag.Assertion)
{
flags |= (1 << (int)PermissionType.SecurityAssert);
}
if ((securityPermissionFlags & SecurityPermissionFlag.SerializationFormatter) == SecurityPermissionFlag.SerializationFormatter)
{
flags |= (1 << (int)PermissionType.SecuritySerialization);
}
if ((securityPermissionFlags & SecurityPermissionFlag.BindingRedirects) == SecurityPermissionFlag.BindingRedirects)
{
flags |= (1 << (int)PermissionType.SecurityBindingRedirects);
}
if ((securityPermissionFlags & SecurityPermissionFlag.ControlEvidence) == SecurityPermissionFlag.ControlEvidence)
{
flags |= (1 << (int)PermissionType.SecurityControlEvidence);
}
if ((securityPermissionFlags & SecurityPermissionFlag.ControlPrincipal) == SecurityPermissionFlag.ControlPrincipal)
{
flags |= (1 << (int)PermissionType.SecurityControlPrincipal);
}
if ((reflectionPermissionFlags & ReflectionPermissionFlag.RestrictedMemberAccess) == ReflectionPermissionFlag.RestrictedMemberAccess)
{
flags |= (1 << (int)PermissionType.ReflectionRestrictedMemberAccess);
}
if ((reflectionPermissionFlags & ReflectionPermissionFlag.MemberAccess) == ReflectionPermissionFlag.MemberAccess)
{
flags |= (1 << (int)PermissionType.ReflectionMemberAccess);
}
return(flags);
}
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Permissions.ReflectionPermission" /> class with the specified access.</summary><param name="flag">One of the <see cref="T:System.Security.Permissions.ReflectionPermissionFlag" /> values. </param><exception cref="T:System.ArgumentException">The <paramref name="flag" /> parameter is not a valid value of <see cref="T:System.Security.Permissions.ReflectionPermissionFlag" />. </exception>
public ReflectionPermission(ReflectionPermissionFlag flag)
{
throw new NotImplementedException();
}
public ReflectionPermission (ReflectionPermissionFlag flag) {
return default(ReflectionPermission);
}
public ReflectionPermission(ReflectionPermissionFlag flag)
{
}
