Пример #1
0
        public void TestAddDeclarativeSecurityDuplicateAction()
        {
            MethodBuilder mb = genClass.DefineMethod(
                genMethodName(), MethodAttributes.Public, typeof(void),
                new Type [0]);
            PermissionSet set = new PermissionSet(PermissionState.Unrestricted);

            mb.AddDeclarativeSecurity(SecurityAction.Demand, set);
            mb.AddDeclarativeSecurity(SecurityAction.Demand, set);
        }
Пример #2
0
    public static void BuildDynMethod(ref ModuleBuilder myModBuilder)
    {
        //<Snippet1>
        // myModBuilder is an instance of ModuleBuilder.
        // Note that for the use of PermissionSet and SecurityAction,
        // the namespaces System.Security and System.Security.Permissions
        // should be included.

        TypeBuilder myTypeBuilder = myModBuilder.DefineType("MyType",
                                                            TypeAttributes.Public);

        MethodBuilder myMethod1 = myTypeBuilder.DefineMethod("MyMethod",
                                                             MethodAttributes.Public,
                                                             typeof(int),
                                                             new Type[]
                                                             { typeof(int), typeof(int) });

        PermissionSet myMethodPermissions = new PermissionSet(
            PermissionState.Unrestricted);

        myMethod1.AddDeclarativeSecurity(SecurityAction.Demand,
                                         myMethodPermissions);

        //</Snippet1>
    }
Пример #3
0
        private static MethodBuilder AddConstructor(TypeBuilder tb, MethodWrapper defaultConstructor, MethodBase serializationConstructor, bool callReadObject)
        {
            MethodBuilder ctor = ReflectUtil.DefineConstructor(tb, MethodAttributes.Family, new Type[] { JVM.Import(typeof(SerializationInfo)), JVM.Import(typeof(StreamingContext)) });

            AttributeHelper.HideFromJava(ctor);
            ctor.AddDeclarativeSecurity(SecurityAction.Demand, psetSerializationFormatter);
            CodeEmitter ilgen = CodeEmitter.Create(ctor);

            ilgen.Emit(OpCodes.Ldarg_0);
            if (defaultConstructor != null)
            {
                defaultConstructor.EmitCall(ilgen);
            }
            else
            {
                ilgen.Emit(OpCodes.Ldarg_1);
                ilgen.Emit(OpCodes.Ldarg_2);
                ilgen.Emit(OpCodes.Call, serializationConstructor);
            }
            if (callReadObject)
            {
                ilgen.Emit(OpCodes.Ldarg_0);
                ilgen.Emit(OpCodes.Ldarg_1);
                TypeWrapper   serializationHelper = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.Serialization");
                MethodWrapper mw = serializationHelper.GetMethodWrapper("readObject", "(Ljava.lang.Object;Lcli.System.Runtime.Serialization.SerializationInfo;)V", false);
                mw.Link();
                mw.EmitCall(ilgen);
            }
            ilgen.Emit(OpCodes.Ret);
            ilgen.DoEmit();
            return(ctor);
        }
Пример #4
0
        internal static void AddGetObjectData(TypeBuilder tb)
        {
            string name = tb.IsSealed
                                ? "System.Runtime.Serialization.ISerializable.GetObjectData"
                                : "GetObjectData";
            MethodAttributes attr = tb.IsSealed
                                ? MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final
                                : MethodAttributes.Family | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride;

            tb.AddInterfaceImplementation(JVM.Import(typeof(ISerializable)));
            MethodBuilder getObjectData = tb.DefineMethod(name, attr, null,
                                                          new Type[] { JVM.Import(typeof(SerializationInfo)), JVM.Import(typeof(StreamingContext)) });

            getObjectData.SetCustomAttribute(securityCriticalAttribute);
            AttributeHelper.HideFromJava(getObjectData);
            getObjectData.AddDeclarativeSecurity(SecurityAction.Demand, psetSerializationFormatter);
            tb.DefineMethodOverride(getObjectData, JVM.Import(typeof(ISerializable)).GetMethod("GetObjectData"));
            CodeEmitter ilgen = CodeEmitter.Create(getObjectData);

            ilgen.Emit(OpCodes.Ldarg_0);
            ilgen.Emit(OpCodes.Ldarg_1);
            TypeWrapper   serializationHelper = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.Serialization");
            MethodWrapper mw = serializationHelper.GetMethodWrapper("writeObject", "(Ljava.lang.Object;Lcli.System.Runtime.Serialization.SerializationInfo;)V", false);

            mw.Link();
            mw.EmitCall(ilgen);
            ilgen.Emit(OpCodes.Ret);
            ilgen.DoEmit();
        }
Пример #5
0
        public void TestAddDeclarativeSecurityNullPermissionSet()
        {
            MethodBuilder mb = genClass.DefineMethod(
                genMethodName(), MethodAttributes.Public, typeof(void),
                new Type [0]);

            mb.AddDeclarativeSecurity(SecurityAction.Demand, null);
        }
Пример #6
0
        public void TestAddDeclarativeSecurityAlreadyCreated()
        {
            MethodBuilder mb = genClass.DefineMethod(
                genMethodName(), MethodAttributes.Public, typeof(void),
                new Type [0]);
            ILGenerator ilgen = mb.GetILGenerator();

            ilgen.Emit(OpCodes.Ret);
            genClass.CreateType();

            PermissionSet set = new PermissionSet(PermissionState.Unrestricted);

            mb.AddDeclarativeSecurity(SecurityAction.Demand, set);
        }
Пример #7
0
        public void TestAddDeclarativeSecurityInvalidAction()
        {
            MethodBuilder mb = genClass.DefineMethod(
                genMethodName(), MethodAttributes.Public, typeof(void),
                new Type [0]);

            SecurityAction [] actions = new SecurityAction [] {
                SecurityAction.RequestMinimum,
                SecurityAction.RequestOptional,
                SecurityAction.RequestRefuse
            };
            PermissionSet set = new PermissionSet(PermissionState.Unrestricted);

            foreach (SecurityAction action in actions)
            {
                try {
                    mb.AddDeclarativeSecurity(action, set);
                    Assert.Fail();
                } catch (ArgumentOutOfRangeException) {
                }
            }
        }
        private static MethodInvoker SpitAndInstantiateClassFor(MethodInfo method, bool requiresDemand)
        {
            TypeBuilder   builder  = Runtime.ThunkModuleBuilder.DefineType("invoker" + count++, TypeAttributes.Public, typeof(MethodInvoker));
            MethodBuilder builder2 = builder.DefineMethod("Invoke", MethodAttributes.Virtual | MethodAttributes.Public, typeof(object), new Type[] { typeof(object), typeof(object[]) });

            if (requiresDemand)
            {
                builder2.AddDeclarativeSecurity(SecurityAction.Demand, new NamedPermissionSet("FullTrust"));
            }
            builder2.SetCustomAttribute(new CustomAttributeBuilder(Runtime.TypeRefs.debuggerStepThroughAttributeCtor, new object[0]));
            builder2.SetCustomAttribute(new CustomAttributeBuilder(Runtime.TypeRefs.debuggerHiddenAttributeCtor, new object[0]));
            ILGenerator iLGenerator = builder2.GetILGenerator();

            if (!method.DeclaringType.IsPublic)
            {
                method = method.GetBaseDefinition();
            }
            Type declaringType = method.DeclaringType;

            if (!method.IsStatic)
            {
                iLGenerator.Emit(OpCodes.Ldarg_1);
                if (declaringType.IsValueType)
                {
                    Microsoft.JScript.Convert.EmitUnbox(iLGenerator, declaringType, Type.GetTypeCode(declaringType));
                    Microsoft.JScript.Convert.EmitLdloca(iLGenerator, declaringType);
                }
                else
                {
                    iLGenerator.Emit(OpCodes.Castclass, declaringType);
                }
            }
            ParameterInfo[] parameters   = method.GetParameters();
            LocalBuilder[]  builderArray = null;
            int             i            = 0;
            int             length       = parameters.Length;

            while (i < length)
            {
                iLGenerator.Emit(OpCodes.Ldarg_2);
                ConstantWrapper.TranslateToILInt(iLGenerator, i);
                Type parameterType = parameters[i].ParameterType;
                if (parameterType.IsByRef)
                {
                    parameterType = parameterType.GetElementType();
                    if (builderArray == null)
                    {
                        builderArray = new LocalBuilder[length];
                    }
                    builderArray[i] = iLGenerator.DeclareLocal(parameterType);
                    iLGenerator.Emit(OpCodes.Ldelem_Ref);
                    if (parameterType.IsValueType)
                    {
                        Microsoft.JScript.Convert.EmitUnbox(iLGenerator, parameterType, Type.GetTypeCode(parameterType));
                    }
                    iLGenerator.Emit(OpCodes.Stloc, builderArray[i]);
                    iLGenerator.Emit(OpCodes.Ldloca, builderArray[i]);
                }
                else
                {
                    iLGenerator.Emit(OpCodes.Ldelem_Ref);
                    if (parameterType.IsValueType)
                    {
                        Microsoft.JScript.Convert.EmitUnbox(iLGenerator, parameterType, Type.GetTypeCode(parameterType));
                    }
                }
                i++;
            }
            if (((!method.IsStatic && method.IsVirtual) && !method.IsFinal) && (!declaringType.IsSealed || !declaringType.IsValueType))
            {
                iLGenerator.Emit(OpCodes.Callvirt, method);
            }
            else
            {
                iLGenerator.Emit(OpCodes.Call, method);
            }
            Type returnType = method.ReturnType;

            if (returnType == typeof(void))
            {
                iLGenerator.Emit(OpCodes.Ldnull);
            }
            else if (returnType.IsValueType)
            {
                iLGenerator.Emit(OpCodes.Box, returnType);
            }
            if (builderArray != null)
            {
                int index = 0;
                int num4  = parameters.Length;
                while (index < num4)
                {
                    LocalBuilder local = builderArray[index];
                    if (local != null)
                    {
                        iLGenerator.Emit(OpCodes.Ldarg_2);
                        ConstantWrapper.TranslateToILInt(iLGenerator, index);
                        iLGenerator.Emit(OpCodes.Ldloc, local);
                        Type elementType = parameters[index].ParameterType.GetElementType();
                        if (elementType.IsValueType)
                        {
                            iLGenerator.Emit(OpCodes.Box, elementType);
                        }
                        iLGenerator.Emit(OpCodes.Stelem_Ref);
                    }
                    index++;
                }
            }
            iLGenerator.Emit(OpCodes.Ret);
            return((MethodInvoker)Activator.CreateInstance(builder.CreateType()));
        }
Пример #9
0
				internal override void Apply(ClassLoaderWrapper loader, MethodBuilder mb, object annotation)
				{
					if (type.IsSubclassOf(Types.SecurityAttribute))
					{
#if STATIC_COMPILER
						mb.__AddDeclarativeSecurity(MakeCustomAttributeBuilder(loader, annotation));
#elif STUB_GENERATOR
#else
						SecurityAction action;
						PermissionSet permSet;
						if (MakeDeclSecurity(type, annotation, out action, out permSet))
						{
							mb.AddDeclarativeSecurity(action, permSet);
						}
#endif
					}
					else
					{
						mb.SetCustomAttribute(MakeCustomAttributeBuilder(loader, annotation));
					}
				}
Пример #10
0
        private static MethodInvoker SpitAndInstantiateClassFor(MethodInfo method, bool requiresDemand)
        {
            TypeBuilder   tb = Runtime.ThunkModuleBuilder.DefineType("invoker" + MethodInvoker.count++, TypeAttributes.Public, typeof(MethodInvoker));
            MethodBuilder mb = tb.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot,
                                               typeof(Object), new Type[] { typeof(Object), typeof(Object[]) });

            if (requiresDemand)
            {
                mb.AddDeclarativeSecurity(SecurityAction.Demand, new NamedPermissionSet("FullTrust"));
            }
#if !DEBUG
            mb.SetCustomAttribute(new CustomAttributeBuilder(Runtime.TypeRefs.debuggerStepThroughAttributeCtor, new Object[] {}));
            mb.SetCustomAttribute(new CustomAttributeBuilder(Runtime.TypeRefs.debuggerHiddenAttributeCtor, new Object[] {}));
#endif
            ILGenerator il = mb.GetILGenerator();
            if (!method.DeclaringType.IsPublic)
            {
                method = method.GetBaseDefinition();
            }
            Type obT = method.DeclaringType;
            if (!method.IsStatic)
            {
                il.Emit(OpCodes.Ldarg_1);
                if (obT.IsValueType)
                {
                    Convert.EmitUnbox(il, obT, Type.GetTypeCode(obT));
                    Convert.EmitLdloca(il, obT);
                }
                else
                {
                    il.Emit(OpCodes.Castclass, obT);
                }
            }
            ParameterInfo[] parameters = method.GetParameters();
            LocalBuilder[]  outTemps   = null;
            for (int i = 0, n = parameters.Length; i < n; i++)
            {
                il.Emit(OpCodes.Ldarg_2);
                ConstantWrapper.TranslateToILInt(il, i);
                Type pt = parameters[i].ParameterType;
                if (pt.IsByRef)
                {
                    pt = pt.GetElementType();
                    if (outTemps == null)
                    {
                        outTemps = new LocalBuilder[n];
                    }
                    outTemps[i] = il.DeclareLocal(pt);
                    il.Emit(OpCodes.Ldelem_Ref);
                    if (pt.IsValueType)
                    {
                        Convert.EmitUnbox(il, pt, Type.GetTypeCode(pt));
                    }
                    il.Emit(OpCodes.Stloc, outTemps[i]);
                    il.Emit(OpCodes.Ldloca, outTemps[i]);
                }
                else
                {
                    il.Emit(OpCodes.Ldelem_Ref);
                    if (pt.IsValueType)
                    {
                        Convert.EmitUnbox(il, pt, Type.GetTypeCode(pt));
                    }
                }
            }
            if (!method.IsStatic && method.IsVirtual && !method.IsFinal && (!obT.IsSealed || !obT.IsValueType))
            {
                il.Emit(OpCodes.Callvirt, method);
            }
            else
            {
                il.Emit(OpCodes.Call, method);
            }
            Type rt = method.ReturnType;
            if (rt == typeof(void))
            {
                il.Emit(OpCodes.Ldnull);
            }
            else if (rt.IsValueType)
            {
                il.Emit(OpCodes.Box, rt);
            }
            if (outTemps != null)
            {
                for (int i = 0, n = parameters.Length; i < n; i++)
                {
                    LocalBuilder loc = outTemps[i];
                    if (loc != null)
                    {
                        il.Emit(OpCodes.Ldarg_2);
                        ConstantWrapper.TranslateToILInt(il, i);
                        il.Emit(OpCodes.Ldloc, loc);
                        Type pt = parameters[i].ParameterType.GetElementType();
                        if (pt.IsValueType)
                        {
                            il.Emit(OpCodes.Box, pt);
                        }
                        il.Emit(OpCodes.Stelem_Ref);
                    }
                }
            }
            il.Emit(OpCodes.Ret);
            Type t = tb.CreateType();
            return((MethodInvoker)Activator.CreateInstance(t));
        }