/// <summary>Determines whether the current permission is a subset of the specified permission.</summary> /// <param name="target">A permission that is to be tested for the subset relationship. This permission must be of the same type as the current permission. </param> /// <returns> /// <see langword="true" /> if the current permission is a subset of the specified permission; otherwise, <see langword="false" />.</returns> /// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not <see langword="null" /> and is not of the same type as the current permission. </exception> // Token: 0x060025F3 RID: 9715 RVA: 0x00088858 File Offset: 0x00086A58 public override bool IsSubsetOf(IPermission target) { if (target == null) { return(this.m_flags == ReflectionPermissionFlag.NoFlags); } bool result; try { ReflectionPermission reflectionPermission = (ReflectionPermission)target; if (reflectionPermission.IsUnrestricted()) { result = true; } else if (this.IsUnrestricted()) { result = false; } else { result = ((this.m_flags & ~reflectionPermission.m_flags) == ReflectionPermissionFlag.NoFlags); } } catch (InvalidCastException) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName })); } return(result); }
public void ReflectionEmit () { ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.ReflectionEmit); Assert ("IsUnrestricted", !p.IsUnrestricted ()); SecurityElement se = p.ToXml (); AssertEquals ("ToXml-Flags=ReflectionEmit", "ReflectionEmit", (se.Attributes ["Flags"] as string)); }
public void Derestricted () { ReflectionPermission p = new ReflectionPermission (PermissionState.Unrestricted); Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted"); p.Flags = ReflectionPermissionFlag.NoFlags; Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted"); }
public bool makeTheRequestQueryStringDataEditable() { try { object objectToReflect = HttpContext.Current.Request.QueryString; string stringObjectType = "MakeReadWrite"; // Assert the retrival of information from a Private Method ReflectionPermission reflectionPerm = new ReflectionPermission(ReflectionPermissionFlag.TypeInformation); reflectionPerm.Assert(); MethodInfo objTempMethodType = objectToReflect.GetType().GetMethod( stringObjectType,BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null,CallingConventions.Any,new Type[0] {},null); // Revert the previous assert since it is only possible to have one active Assert ReflectionPermission.RevertAssert(); // Assert the execution of a Private Method reflectionPerm = new ReflectionPermission(ReflectionPermissionFlag.MemberAccess); reflectionPerm.Assert(); object invokeResult = objTempMethodType.Invoke( objectToReflect,BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod,null,new object[0] {} ,null); return true; } catch (Exception ex) { HttpContext.Current.Response.Write(ex.Message); return false; } }
public void MemberAccess () { ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess); Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted"); SecurityElement se = p.ToXml (); Assert.AreEqual ("MemberAccess", (se.Attributes ["Flags"] as string), "ToXml-Flags=MemberAccess"); }
public void TypeInformation () { ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation); Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted"); SecurityElement se = p.ToXml (); Assert.AreEqual ("TypeInformation", (se.Attributes ["Flags"] as string), "ToXml-Flags=TypeInformation"); }
// // 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 void Derestricted () { ReflectionPermission p = new ReflectionPermission (PermissionState.Unrestricted); Assert ("IsUnrestricted", p.IsUnrestricted ()); p.Flags = ReflectionPermissionFlag.NoFlags; Assert ("IsUnrestricted", !p.IsUnrestricted ()); }
public override bool IsSubsetOf(IPermission target) { if (target == null) { return(m_flags == ReflectionPermissionFlag.NoFlags); } try { ReflectionPermission operand = (ReflectionPermission)target; if (operand.IsUnrestricted()) { return(true); } else if (this.IsUnrestricted()) { return(false); } else { return((((int)this.m_flags) & ~((int)operand.m_flags)) == 0); } } catch (InvalidCastException) { throw new ArgumentException( Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) ); } }
/// <summary>Creates and returns a permission that is the intersection of the current permission and the specified permission.</summary> /// <returns>A new permission that represents the intersection of the current permission and the specified permission. This new permission is null if the intersection is empty.</returns> /// <param name="target">A permission to intersect with the current permission. It must be of the same type as the current permission. </param> /// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not null and is not of the same type as the current permission. </exception> public override IPermission Intersect(IPermission target) { ReflectionPermission reflectionPermission = this.Cast(target); if (reflectionPermission == null) { return(null); } if (this.IsUnrestricted()) { if (reflectionPermission.Flags == ReflectionPermissionFlag.NoFlags) { return(null); } return(reflectionPermission.Copy()); } else { if (!reflectionPermission.IsUnrestricted()) { ReflectionPermission reflectionPermission2 = (ReflectionPermission)reflectionPermission.Copy(); reflectionPermission2.Flags &= this.flags; return((reflectionPermission2.Flags != ReflectionPermissionFlag.NoFlags) ? reflectionPermission2 : null); } if (this.flags == ReflectionPermissionFlag.NoFlags) { return(null); } return(this.Copy()); } }
public override bool IsSubsetOf(IPermission target) { bool flag; if (target == null) { return(this.m_flags == ReflectionPermissionFlag.NoFlags); } try { ReflectionPermission permission = (ReflectionPermission)target; if (permission.IsUnrestricted()) { return(true); } if (this.IsUnrestricted()) { return(false); } flag = (this.m_flags & ~permission.m_flags) == ReflectionPermissionFlag.NoFlags; } catch (InvalidCastException) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName })); } return(flag); }
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 void MemberAccess () { ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess); Assert ("IsUnrestricted", !p.IsUnrestricted ()); SecurityElement se = p.ToXml (); AssertEquals ("ToXml-Flags=MemberAccess", "MemberAccess", (se.Attributes ["Flags"] as string)); }
public void ReflectionEmit () { ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.ReflectionEmit); Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted"); SecurityElement se = p.ToXml (); Assert.AreEqual ("ReflectionEmit", (se.Attributes ["Flags"] as string), "ToXml-Flags=ReflectionEmit"); }
private static void GetPermissions() { if (!m_Initialized) { //test RelectionPermission CodeAccessPermission securityTest; try { securityTest = new ReflectionPermission(PermissionState.Unrestricted); securityTest.Demand(); m_ReflectionPermission = true; } catch { //code access security error m_ReflectionPermission = false; } //test WebPermission try { securityTest = new WebPermission(PermissionState.Unrestricted); securityTest.Demand(); m_WebPermission = true; } catch { //code access security error m_WebPermission = false; } //test WebHosting Permission (Full Trust) try { securityTest = new AspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted); securityTest.Demand(); m_AspNetHostingPermission = true; } catch { //code access security error m_AspNetHostingPermission = false; } m_Initialized = true; //Test for Unmanaged Code permission try { securityTest = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); securityTest.Demand(); m_UnManagedCodePermission = true; } catch (Exception e) { m_UnManagedCodePermission = false; } } }
public PrivateObjectTester (object instance) { perm = new ReflectionPermission(PermissionState.Unrestricted); perm.Demand(); type = Type.GetTypeFromHandle(Type.GetTypeHandle(instance)); this.instance = instance; }
public void PermissionStateUnrestricted () { ReflectionPermission p = new ReflectionPermission (PermissionState.Unrestricted); AssertNotNull ("ReflectionPermission(PermissionState.Unrestricted)", p); Assert ("IsUnrestricted", p.IsUnrestricted ()); ReflectionPermission copy = (ReflectionPermission) p.Copy (); AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ()); SecurityElement se = p.ToXml (); AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string)); }
public void PermissionStateUnrestricted () { ReflectionPermission p = new ReflectionPermission (PermissionState.Unrestricted); Assert.IsNotNull (p, "ReflectionPermission(PermissionState.Unrestricted)"); Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted"); ReflectionPermission copy = (ReflectionPermission) p.Copy (); Assert.AreEqual (p.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted"); SecurityElement se = p.ToXml (); Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "ToXml-Unrestricted"); }
public void PermissionStateNone () { ReflectionPermission p = new ReflectionPermission (PermissionState.None); Assert.IsNotNull (p, "ReflectionPermission(PermissionState.None)"); Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted"); ReflectionPermission copy = (ReflectionPermission) p.Copy (); Assert.AreEqual (p.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted"); SecurityElement se = p.ToXml (); Assert.IsTrue ((se.Attributes ["class"] as string).StartsWith (className), "ToXml-class"); Assert.AreEqual ("1", (se.Attributes ["version"] as string), "ToXml-version"); }
public void PermissionStateNone () { ReflectionPermission p = new ReflectionPermission (PermissionState.None); AssertNotNull ("ReflectionPermission(PermissionState.None)", p); Assert ("IsUnrestricted", !p.IsUnrestricted ()); ReflectionPermission copy = (ReflectionPermission) p.Copy (); AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ()); SecurityElement se = p.ToXml (); Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className)); AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string)); }
private Type type; // type of class to manage #endregion Fields #region Constructors public PrivateObjectReflector(string qualifiedTypeName, params object[] args) { perm = new ReflectionPermission(PermissionState.Unrestricted); perm.Demand(); type = Type.GetType(qualifiedTypeName); Type[] types = new Type[args.Length]; for (int i = 0; i < args.Length; i++) { types[i] = args[i].GetType(); } instance = type.GetConstructor(bindingFlags, null, types, null).Invoke(args); }
public void CannotInvokeNonPublicMethodWhenCallsMadeDirectly() { ReflectionPermission permission = new ReflectionPermission(ReflectionPermissionFlag.TypeInformation); permission.Deny(); XmlIncludeTypeDataCollection xmlIncludeTypes = new XmlIncludeTypeDataCollection(); xmlIncludeTypes.Add(new XmlIncludeTypeData("shouldNotBeAccessible", typeof(TestingInternal.ShouldNotBeAccessible).AssemblyQualifiedName)); RuntimeConfigurationView view = new RuntimeConfigurationView(new ConfigurationContext(new ConfigurationDictionary())); Type [] collectedTypes = view.CollectTypes(xmlIncludeTypes); Assert.AreEqual(1, collectedTypes.Length); }
/// <summary>Determines whether the current permission is a subset of the specified permission.</summary> /// <returns>true if the current permission is a subset of the specified permission; otherwise, false.</returns> /// <param name="target">A permission that is to be tested for the subset relationship. This permission must be of the same type as the current permission. </param> /// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not null and is not of the same type as the current permission. </exception> public override bool IsSubsetOf(IPermission target) { ReflectionPermission reflectionPermission = this.Cast(target); if (reflectionPermission == null) { return(this.flags == ReflectionPermissionFlag.NoFlags); } if (this.IsUnrestricted()) { return(reflectionPermission.IsUnrestricted()); } return(reflectionPermission.IsUnrestricted() || (this.flags & reflectionPermission.Flags) == this.flags); }
private ReflectionPermission Cast(IPermission target) { if (target == null) { return(null); } ReflectionPermission reflectionPermission = target as ReflectionPermission; if (reflectionPermission == null) { CodeAccessPermission.ThrowInvalidPermission(target, typeof(ReflectionPermission)); } return(reflectionPermission); }
// Methods public override IPermission CreatePermission() { ReflectionPermission perm = null; if (this.Unrestricted) { perm = new ReflectionPermission(PermissionState.Unrestricted); } else { perm = new ReflectionPermission(flags); } return(perm); }
public void CannotInvokeNonPublicMethodWhenCallsMadeThroughReflection() { ReflectionPermission permission = new ReflectionPermission(ReflectionPermissionFlag.TypeInformation); permission.Deny(); XmlIncludeTypeDataCollection xmlIncludeTypes = new XmlIncludeTypeDataCollection(); xmlIncludeTypes.Add(new XmlIncludeTypeData("shouldNotBeAccessible", typeof(TestingInternal.ShouldNotBeAccessible).AssemblyQualifiedName)); RuntimeConfigurationView view = new RuntimeConfigurationView(new ConfigurationContext(new ConfigurationDictionary())); MethodInfo collectTypes = view.GetType().GetMethod("CollectTypes", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(XmlIncludeTypeDataCollection)}, null); object returnedTypes = collectTypes.Invoke(view, new object[] { xmlIncludeTypes }); Type [] collectedTypes = returnedTypes as Type[]; Assert.AreEqual(1, collectedTypes.Length); }
// helpers private ReflectionPermission Cast(IPermission target) { if (target == null) { return(null); } ReflectionPermission rp = (target as ReflectionPermission); if (rp == null) { ThrowInvalidPermission(target, typeof(ReflectionPermission)); } return(rp); }
public IPermission Parse(JToken token) { var items = token as JArray; if (items == null) { return null; } var result = new ReflectionPermission(PermissionState.None); var flags = items.ToObject<string[]>(); if (flags.Contains("memberAccess")) result.Flags |= ReflectionPermissionFlag.MemberAccess; if (flags.Contains("restrictedMemberAccess")) result.Flags |= ReflectionPermissionFlag.RestrictedMemberAccess; return result; }
/// <summary>Creates a permission that is the union of the current permission and the specified permission.</summary> /// <returns>A new permission that represents the union of the current permission and the specified permission.</returns> /// <param name="other">A permission to combine with the current permission. It must be of the same type as the current permission. </param> /// <exception cref="T:System.ArgumentException">The <paramref name="other" /> parameter is not null and is not of the same type as the current permission. </exception> public override IPermission Union(IPermission other) { ReflectionPermission reflectionPermission = this.Cast(other); if (other == null) { return(this.Copy()); } if (this.IsUnrestricted() || reflectionPermission.IsUnrestricted()) { return(new ReflectionPermission(PermissionState.Unrestricted)); } ReflectionPermission reflectionPermission2 = (ReflectionPermission)reflectionPermission.Copy(); reflectionPermission2.Flags |= this.flags; return(reflectionPermission2); }
internal static Expression InjectReflectionPermissionIfNecessary(MethodInfo method, Expression expression) { if (method == null) { return expression; } if (method.IsPublic) { return expression; } else { ReflectionPermission reflectionMemberAccessPermission = new ReflectionPermission(ReflectionPermissionFlag.MemberAccess); Expression demandExpression = Expression.Call(Expression.Constant(reflectionMemberAccessPermission), "Demand", null, null); return Expression.Block(expression.Type, demandExpression, expression); } }
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 permission = (ReflectionPermission)other; if (this.IsUnrestricted() || permission.IsUnrestricted()) { return(new ReflectionPermission(PermissionState.Unrestricted)); } return(new ReflectionPermission(this.m_flags | permission.m_flags)); }
public static PermissionToken FindToken( Type cls ) { if (cls == null) return null; if (cls.GetInterface( "System.Security.Permissions.IBuiltInPermission" ) != null) { if (s_reflectPerm == null) s_reflectPerm = new ReflectionPermission(PermissionState.Unrestricted); s_reflectPerm.Assert(); MethodInfo method = cls.GetMethod( "GetTokenIndex", BindingFlags.Static | BindingFlags.NonPublic ); BCLDebug.Assert( method != null, "IBuiltInPermission types should have a static method called 'GetTokenIndex'" ); return s_theTokenFactory.BuiltInGetToken( (int)method.Invoke( null, null ), null, cls ); } else { return s_theTokenFactory.FindToken( cls ); } }
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)); }
public static PermissionToken FindToken(Type cls) { if (cls == null) { return null; } if (cls.GetInterface("System.Security.Permissions.IBuiltInPermission") == null) { return s_theTokenFactory.FindToken(cls); } if (s_reflectPerm == null) { s_reflectPerm = new ReflectionPermission(PermissionState.Unrestricted); } s_reflectPerm.Assert(); RuntimeMethodInfo method = cls.GetMethod("GetTokenIndex", BindingFlags.NonPublic | BindingFlags.Static) as RuntimeMethodInfo; int index = (int) method.Invoke(null, BindingFlags.Default, null, null, null, true); return s_theTokenFactory.BuiltInGetToken(index, null, cls); }
public override IPermission Union(IPermission other) { ReflectionPermission rp = Cast(other); if (other == null) { return(Copy()); } if (IsUnrestricted() || rp.IsUnrestricted()) { return(new ReflectionPermission(PermissionState.Unrestricted)); } ReflectionPermission p = (ReflectionPermission)rp.Copy(); p.Flags |= flags; return(p); }
public override bool IsSubsetOf(IPermission target) { ReflectionPermission rp = Cast(target); if (rp == null) { return(flags == ReflectionPermissionFlag.NoFlags); } if (IsUnrestricted()) { return(rp.IsUnrestricted()); } else if (rp.IsUnrestricted()) { return(true); } return((flags & rp.Flags) == flags); }
private static void GetPermissions() { if (!m_Initialized) { // test RelectionPermission System.Security.CodeAccessPermission securityTest; try { securityTest = new ReflectionPermission(PermissionState.Unrestricted); securityTest.Demand(); m_ReflectionPermission = true; } catch { m_ReflectionPermission = false; } // test WebPermission try { securityTest = new System.Net.WebPermission(PermissionState.Unrestricted); securityTest.Demand(); m_WebPermission = true; } catch { m_WebPermission = false; } // test WebHosting Permission (Full Trust) try { securityTest = new AspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted); securityTest.Demand(); m_AspNetHostingPermission = true; } catch { m_AspNetHostingPermission = false; } m_Initialized = true; } }
public override IPermission Intersect(IPermission target) { ReflectionPermission rp = Cast(target); if (rp == null) { return(null); } if (IsUnrestricted()) { if (rp.Flags == ReflectionPermissionFlag.NoFlags) { return(null); } else { return(rp.Copy()); } } if (rp.IsUnrestricted()) { if (flags == ReflectionPermissionFlag.NoFlags) { return(null); } else { return(Copy()); } } ReflectionPermission p = (ReflectionPermission)rp.Copy(); p.Flags &= flags; return((p.Flags == ReflectionPermissionFlag.NoFlags) ? null : p); }
/// <summary>确定当前权限是否为指定权限的子集。</summary> /// <returns>如果当前权限是指定权限的子集,则为 true;否则为 false。</returns> /// <param name="target">将要测试子集关系的权限。此权限必须与当前权限属于同一类型。</param> /// <exception cref="T:System.ArgumentException"> /// <paramref name="target" /> 参数不是 null,而且与当前权限不是同一类型。</exception> public override bool IsSubsetOf(IPermission target) { if (target == null) { return(this.m_flags == ReflectionPermissionFlag.NoFlags); } try { ReflectionPermission reflectionPermission = (ReflectionPermission)target; if (reflectionPermission.IsUnrestricted()) { return(true); } if (this.IsUnrestricted()) { return(false); } return((this.m_flags & ~reflectionPermission.m_flags) == ReflectionPermissionFlag.NoFlags); } catch (InvalidCastException ex) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", (object)this.GetType().FullName)); } }
static XPathDocumentWriter() { ReflectionPermission perm = new ReflectionPermission(PermissionState.Unrestricted); perm.Flags = ReflectionPermissionFlag.MemberAccess; try { perm.Assert(); Type t = typeof(XPathDocument); defaultConstructor = t.GetConstructor( BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, new ParameterModifier[0]); Debug.Assert(defaultConstructor != null, ".NET Framework implementation changed"); loadWriterMethod = t.GetMethod("LoadFromWriter", BindingFlags.Instance | BindingFlags.NonPublic); Debug.Assert(loadWriterMethod != null, ".NET Framework implementation changed"); } finally { CodeAccessPermission.RevertAssert(); } }
/// <internalonly/> int IBuiltInPermission.GetTokenIndex() { return(ReflectionPermission.GetTokenIndex()); }
// Methods public override IPermission CreatePermission () { #if NET_2_1 return null; #else ReflectionPermission perm = null; if (this.Unrestricted) perm = new ReflectionPermission (PermissionState.Unrestricted); else perm = new ReflectionPermission (flags); return perm; #endif }
public static PermissionToken FindToken( Type cls ) { if (cls == null) return null; #if FEATURE_CAS_POLICY if (cls.GetInterface( "System.Security.Permissions.IBuiltInPermission" ) != null) { if (s_reflectPerm == null) s_reflectPerm = new ReflectionPermission(PermissionState.Unrestricted); s_reflectPerm.Assert(); MethodInfo method = cls.GetMethod( "GetTokenIndex", BindingFlags.Static | BindingFlags.NonPublic ); Contract.Assert( method != null, "IBuiltInPermission types should have a static method called 'GetTokenIndex'" ); // GetTokenIndex needs to be invoked without any security checks, since doing a security check // will involve a ReflectionTargetDemand which creates a CompressedStack and attempts to get the // token. RuntimeMethodInfo getTokenIndex = method as RuntimeMethodInfo; Contract.Assert(getTokenIndex != null, "method is not a RuntimeMethodInfo"); int token = (int)getTokenIndex.UnsafeInvoke(null, BindingFlags.Default, null, null, null); return s_theTokenFactory.BuiltInGetToken(token, null, cls); } else #endif // FEATURE_CAS_POLICY { return s_theTokenFactory.FindToken( cls ); } }
public static object InvokePropertyOrMethod(string className, string methodName, object[] parameters, InvokeType invokeType) { System.Security.Permissions.ReflectionPermission perm = new System.Security.Permissions.ReflectionPermission( System.Security.Permissions.PermissionState.Unrestricted); perm.Assert(); Type type; bool isGetProperty; object[] newargs; object instance; BindingFlags defaultFlags; object resultObject; //if (ActionManager.IsInvokeTypeStatic(invokeType)) //{ // if (String.IsNullOrEmpty(className)) // { // throw new ArgumentException( // "className cannot be null or empty for static invocations", // "className"); // } // type = ReflectionUtils.FindType(className); // if (type == null) // { // throw new InvalidOperationException("FindType fails"); // } //} //else //{ if (parameters == null || parameters.Length == 0) { throw new ArgumentException( "parameters cannot be null or empty for instance invocations", "parameters"); } if (parameters[0] == null) { throw new ArgumentException( "parameters cannot have a null first element for instance invocations", "parameters"); } type = parameters[0].GetType(); //} System.Diagnostics.Debug.Assert(type != null); defaultFlags = BindingFlags.ExactBinding | BindingFlags.Public; newargs = null; instance = null; switch (invokeType) { case InvokeType.StaticMethod: defaultFlags |= BindingFlags.InvokeMethod; defaultFlags |= BindingFlags.Static; break; case InvokeType.InstanceMethod: defaultFlags |= BindingFlags.InvokeMethod; defaultFlags |= BindingFlags.Instance; instance = ExtractFirstParameterAsInstance(parameters, ref newargs); parameters = newargs; break; case InvokeType.GetStaticProperty: defaultFlags |= BindingFlags.GetProperty; defaultFlags |= BindingFlags.Static; break; case InvokeType.SetStaticProperty: defaultFlags |= BindingFlags.SetProperty; defaultFlags |= BindingFlags.Static; break; case InvokeType.GetInstanceProperty: defaultFlags |= BindingFlags.GetProperty; defaultFlags |= BindingFlags.Instance; instance = ExtractFirstParameterAsInstance(parameters, ref newargs); parameters = newargs; break; case InvokeType.SetInstanceProperty: defaultFlags |= BindingFlags.SetProperty; defaultFlags |= BindingFlags.Instance; instance = ExtractFirstParameterAsInstance(parameters, ref newargs); parameters = newargs; break; case InvokeType.GetStaticField: defaultFlags |= BindingFlags.GetField; defaultFlags |= BindingFlags.Static; break; case InvokeType.SetStaticField: defaultFlags |= BindingFlags.SetField; defaultFlags |= BindingFlags.Static; break; case InvokeType.GetInstanceField: defaultFlags |= BindingFlags.GetField; defaultFlags |= BindingFlags.Instance; instance = ExtractFirstParameterAsInstance(parameters, ref newargs); parameters = newargs; break; case InvokeType.SetInstanceField: defaultFlags |= BindingFlags.SetField; defaultFlags |= BindingFlags.Instance; instance = ExtractFirstParameterAsInstance(parameters, ref newargs); parameters = newargs; break; } try { resultObject = type.InvokeMember( methodName, defaultFlags, null, instance, parameters); } catch (MissingMethodException e) { isGetProperty = invokeType == InvokeType.GetInstanceProperty || invokeType == InvokeType.GetStaticProperty; if (parameters.Length > 0 && isGetProperty) { } throw; } catch (AmbiguousMatchException e) { throw; } return(resultObject); }
public void AllFlags () { ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.AllFlags); Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted"); SecurityElement se = p.ToXml (); Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "ToXml-Unrestricted"); }
private static string GetReflectionPermission (ReflectionPermission rp) { return String.Format (" ReflectionPermission\\l {0}\\l", (rp as ReflectionPermission).Flags); }
internal void SetAttributes(IDataReader reader) { // allow access to private fields ReflectionPermission perm = new ReflectionPermission(ReflectionPermissionFlag.NoFlags); perm.Demand(); perm.Assert(); try { IDictionary TimeSheetFieldMappings = GetDataLink().FieldMappings; _log.Debug("SetAttributes: starting for loop (" + this.GetType().FullName + ")"); for (int i = 0; i < reader.FieldCount; i++) { try { // Get the field mapping entry corresponding to the database column name TimeSheetFieldMap TimeSheetFieldMap = null; foreach (TimeSheetFieldMap TimeSheetFieldMap2 in TimeSheetFieldMappings.Values) { if (TimeSheetFieldMap2.FieldName == reader.GetName(i)) { TimeSheetFieldMap = TimeSheetFieldMap2; break; } } if (TimeSheetFieldMap == null) { //throw new ApplicationException(string.Format("Could not locate {0} in field mappings.", reader.GetName(i))); } // Read the object from the database. This may be a plain value // Enum stored as an integer in the database object value; if (!reader.IsDBNull(i)) { if (TimeSheetFieldMap.IsEnum) { // the database field holds the int value for an enum _log.Debug("SetAttributes: Setting enum value for " + TimeSheetFieldMap.AttributeName); object enumValue = GetObjectFromDatabase(reader, i); value = Enum.ToObject(TimeSheetFieldMap.EnumType, enumValue); } else { // the database field holds the attribute value _log.Debug("SetAttributes: Setting direct value for " + TimeSheetFieldMap.AttributeName); value = GetObjectFromDatabase(reader, i); } } else { value = null; } _log.Debug("SetAttributes: now setting field " + TimeSheetFieldMap.FieldInfo + " to " + value); // set the instance's field to the value try { TimeSheetFieldMap.FieldInfo.SetValue(this, value); } catch { _log.Debug("Exception caught in FieldInfo.SetValue setting field {0} to {1}.", TimeSheetFieldMap.FieldInfo, value); //throw; } _log.Debug("SetAttributes: Setting " + TimeSheetFieldMap.FieldName + " to " + value); } catch (Exception e) { _log.Debug("Exception caught reading {0}, column {1}, column name '{2}'.", e, this.GetType().Name, i, reader.GetName(i)); //throw; } } } finally { CodeAccessPermission.RevertAssert(); } _log.Debug("SetAttributes: done (" + this.GetType().FullName + ")"); }
public ArrayList GetIntfObjects(Type intfType) { ArrayList aRet = new ArrayList(); ReflectionPermission reflectionPerm1 = new ReflectionPermission(PermissionState.None); reflectionPerm1.Flags = ReflectionPermissionFlag.AllFlags; if (intfType.IsInterface) { Type type = this.GetType(); FieldInfo[] myFields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly); for (int i = 0; i < myFields.Length; i++) { object newobj = myFields[i].GetValue(this); if ((null != newobj) && (null != newobj.GetType().GetInterface(intfType.Name))) { aRet.Add(newobj); } } } return aRet; }
public void IsSubsetOfBadPermission () { ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags); EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted); Assert.IsTrue (p1.IsSubsetOf (ep2), "IsSubsetOf(EnvironmentPermission)"); }