[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable public override Object Invoke(BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture) { INVOCATION_FLAGS invocationFlags = InvocationFlags; // get the declaring TypeHandle early for consistent exceptions in IntrospectionOnly context RuntimeTypeHandle declaringTypeHandle = m_declaringType.TypeHandle; if ((invocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE | INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS | INVOCATION_FLAGS.INVOCATION_FLAGS_NO_CTOR_INVOKE)) != 0) { ThrowNoInvokeException(); } #if FEATURE_APPX if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NON_W8P_FX_API) != 0) { StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; RuntimeAssembly caller = RuntimeAssembly.GetExecutingAssembly(ref stackMark); if (caller != null && !caller.IsSafeForReflection()) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_APIInvalidForCurrentContext", FullName)); } } #endif if ((invocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_RISKY_METHOD | INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY | INVOCATION_FLAGS.INVOCATION_FLAGS_IS_DELEGATE_CTOR)) != 0) { #if !FEATURE_CORECLR if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_RISKY_METHOD) != 0) { CodeAccessPermission.Demand(PermissionType.ReflectionMemberAccess); } if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY) != 0) #endif // !FEATURE_CORECLR RuntimeMethodHandle.PerformSecurityCheck(null, this, m_declaringType, (uint)(m_invocationFlags | INVOCATION_FLAGS.INVOCATION_FLAGS_CONSTRUCTOR_INVOKE)); #if !FEATURE_CORECLR if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_IS_DELEGATE_CTOR) != 0) { new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand(); } #endif // !FEATURE_CORECLR } // get the signature Signature sig = Signature; int formalCount = sig.Arguments.Length; int actualCount = (parameters != null) ? parameters.Length : 0; if (formalCount != actualCount) { throw new TargetParameterCountException(Environment.GetResourceString("Arg_ParmCnt")); } // We don't need to explicitly invoke the class constructor here, // JIT/NGen will insert the call to .cctor in the instance ctor. // if we are here we passed all the previous checks. Time to look at the arguments if (actualCount > 0) { Object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, sig); Object retValue = RuntimeMethodHandle.InvokeMethod(null, arguments, sig, true); // copy out. This should be made only if ByRef are present. for (int index = 0; index < arguments.Length; index++) { parameters[index] = arguments[index]; } return(retValue); } return(RuntimeMethodHandle.InvokeMethod(null, null, sig, true)); }
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable public override Object Invoke( Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture) { INVOCATION_FLAGS invocationFlags = InvocationFlags; if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != 0) { ThrowNoInvokeException(); } // check basic method consistency. This call will throw if there are problems in the target/method relationship CheckConsistency(obj); #if FEATURE_APPX if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NON_W8P_FX_API) != 0) { StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; RuntimeAssembly caller = RuntimeAssembly.GetExecutingAssembly(ref stackMark); if (caller != null && !caller.IsSafeForReflection()) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_APIInvalidForCurrentContext", FullName)); } } #endif if (obj != null) { #if FEATURE_CORECLR // For unverifiable code, we require the caller to be critical. // Adding the INVOCATION_FLAGS_NEED_SECURITY flag makes that check happen invocationFlags |= INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY; #else // FEATURE_CORECLR new SecurityPermission(SecurityPermissionFlag.SkipVerification).Demand(); #endif // FEATURE_CORECLR } #if !FEATURE_CORECLR if ((invocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_RISKY_METHOD | INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY)) != 0) { if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_RISKY_METHOD) != 0) { CodeAccessPermission.Demand(PermissionType.ReflectionMemberAccess); } if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY) != 0) { RuntimeMethodHandle.PerformSecurityCheck(obj, this, m_declaringType, (uint)m_invocationFlags); } } #endif // !FEATURE_CORECLR Signature sig = Signature; // get the signature int formalCount = sig.Arguments.Length; int actualCount = (parameters != null) ? parameters.Length : 0; if (formalCount != actualCount) { throw new TargetParameterCountException(Environment.GetResourceString("Arg_ParmCnt")); } // if we are here we passed all the previous checks. Time to look at the arguments if (actualCount > 0) { Object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, sig); Object retValue = RuntimeMethodHandle.InvokeMethod(obj, arguments, sig, false); // copy out. This should be made only if ByRef are present. for (int index = 0; index < arguments.Length; index++) { parameters[index] = arguments[index]; } return(retValue); } return(RuntimeMethodHandle.InvokeMethod(obj, null, sig, false)); }
internal void Serialize(object graph, Header[] inHeaders, __BinaryWriter serWriter, bool fCheck) { if (graph == null) { throw new ArgumentNullException("graph", Environment.GetResourceString("ArgumentNull_Graph")); } if (serWriter == null) { throw new ArgumentNullException("serWriter", Environment.GetResourceString("ArgumentNull_WithParamName", new object[] { "serWriter" })); } if (fCheck) { CodeAccessPermission.Demand(PermissionType.SecuritySerialization); } this.serWriter = serWriter; this.headers = inHeaders; serWriter.WriteBegin(); long headerId = 0L; bool flag2 = false; bool flag3 = false; IMethodCallMessage mcm = graph as IMethodCallMessage; if (mcm != null) { flag2 = true; graph = this.WriteMethodCall(mcm); } else { IMethodReturnMessage mrm = graph as IMethodReturnMessage; if (mrm != null) { flag3 = true; graph = this.WriteMethodReturn(mrm); } } if (graph == null) { this.WriteSerializedStreamHeader(this.topId, headerId); if (flag2) { serWriter.WriteMethodCall(); } else if (flag3) { serWriter.WriteMethodReturn(); } serWriter.WriteSerializationHeaderEnd(); serWriter.WriteEnd(); } else { object obj2; long num2; bool flag; this.m_idGenerator = new ObjectIDGenerator(); this.m_objectQueue = new Queue(); this.m_formatterConverter = new FormatterConverter(); this.serObjectInfoInit = new SerObjectInfoInit(); this.topId = this.InternalGetId(graph, false, null, out flag); if (this.headers != null) { headerId = this.InternalGetId(this.headers, false, null, out flag); } else { headerId = -1L; } this.WriteSerializedStreamHeader(this.topId, headerId); if (flag2) { serWriter.WriteMethodCall(); } else if (flag3) { serWriter.WriteMethodReturn(); } if ((this.headers != null) && (this.headers.Length > 0)) { this.m_objectQueue.Enqueue(this.headers); } if (graph != null) { this.m_objectQueue.Enqueue(graph); } while ((obj2 = this.GetNext(out num2)) != null) { WriteObjectInfo objectInfo = null; if (obj2 is WriteObjectInfo) { objectInfo = (WriteObjectInfo)obj2; } else { objectInfo = WriteObjectInfo.Serialize(obj2, this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, this, this.m_binder); objectInfo.assemId = this.GetAssemblyId(objectInfo); } objectInfo.objectId = num2; NameInfo memberNameInfo = this.TypeToNameInfo(objectInfo); this.Write(objectInfo, memberNameInfo, memberNameInfo); this.PutNameInfo(memberNameInfo); objectInfo.ObjectEnd(); } serWriter.WriteSerializationHeaderEnd(); serWriter.WriteEnd(); this.m_objectManager.RaiseOnSerializedEvent(); } }
/// <summary> /// Forces a System.Security.SecurityException at run time if all callers higher /// in the call stack have not been granted the permission specified by the current /// instance. /// </summary> /// <exception cref="System.Security.SecurityException">A caller higher in the call /// stack does not have the permission specified by the current instance</exception> public void Demand() { _permission.Demand(); }
/// <summary> /// Make a Demand of the given permission /// </summary> /// <param name="p"></param> internal static void Demand(CodeAccessPermission p) { p.Demand(); }
internal void Serialize(object graph, Header[] inHeaders, __BinaryWriter serWriter, bool fCheck) { if (graph == null) { throw new ArgumentNullException("graph", Environment.GetResourceString("ArgumentNull_Graph")); } if (serWriter == null) { throw new ArgumentNullException("serWriter", Environment.GetResourceString("ArgumentNull_WithParamName", (object)"serWriter")); } if (fCheck) { CodeAccessPermission.Demand(PermissionType.SecuritySerialization); } this.serWriter = serWriter; this.headers = inHeaders; serWriter.WriteBegin(); long headerId = 0; bool flag1 = false; bool flag2 = false; IMethodCallMessage mcm = graph as IMethodCallMessage; if (mcm != null) { flag1 = true; graph = (object)this.WriteMethodCall(mcm); } else { IMethodReturnMessage mrm = graph as IMethodReturnMessage; if (mrm != null) { flag2 = true; graph = (object)this.WriteMethodReturn(mrm); } } if (graph == null) { this.WriteSerializedStreamHeader(this.topId, headerId); if (flag1) { serWriter.WriteMethodCall(); } else if (flag2) { serWriter.WriteMethodReturn(); } serWriter.WriteSerializationHeaderEnd(); serWriter.WriteEnd(); } else { this.m_idGenerator = new ObjectIDGenerator(); this.m_objectQueue = new Queue(); this.m_formatterConverter = (IFormatterConverter) new FormatterConverter(); this.serObjectInfoInit = new SerObjectInfoInit(); bool isNew; this.topId = this.InternalGetId(graph, false, (Type)null, out isNew); this.WriteSerializedStreamHeader(this.topId, this.headers == null ? -1L : this.InternalGetId((object)this.headers, false, (Type)null, out isNew)); if (flag1) { serWriter.WriteMethodCall(); } else if (flag2) { serWriter.WriteMethodReturn(); } if (this.headers != null && this.headers.Length != 0) { this.m_objectQueue.Enqueue((object)this.headers); } if (graph != null) { this.m_objectQueue.Enqueue(graph); } object next; long objID; while ((next = this.GetNext(out objID)) != null) { WriteObjectInfo objectInfo1; if (next is WriteObjectInfo) { objectInfo1 = (WriteObjectInfo)next; } else { objectInfo1 = WriteObjectInfo.Serialize(next, this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, this, this.m_binder); objectInfo1.assemId = this.GetAssemblyId(objectInfo1); } objectInfo1.objectId = objID; NameInfo nameInfo1 = this.TypeToNameInfo(objectInfo1); WriteObjectInfo objectInfo2 = objectInfo1; NameInfo nameInfo2 = nameInfo1; this.Write(objectInfo2, nameInfo2, nameInfo2); this.PutNameInfo(nameInfo1); objectInfo1.ObjectEnd(); } serWriter.WriteSerializationHeaderEnd(); serWriter.WriteEnd(); this.m_objectManager.RaiseOnSerializedEvent(); } }
internal RSACryptoServiceProvider(int dwKeySize, CspParameters parameters, bool useDefaultKeySize) { int hr; // // Save the CSP Parameters // if (parameters == null) { _parameters = new CspParameters(1, null, null, m_UseMachineKeyStore); } else { // Check the parameter options: specifying either a key container name or UseDefaultKeyContainer flag // requires unmanaged code permission if (((parameters.Flags & CspProviderFlags.UseDefaultKeyContainer) != 0) || ((parameters.KeyContainerName != null) && (parameters.KeyContainerName.Length > 0))) { _UCpermission.Demand(); // If we specified a key container name for this key, then mark it persisted if ((parameters.KeyContainerName != null) && (parameters.KeyContainerName.Length > 0)) { // CAPI doesn't accept Container Names longer than 260 characters if (parameters.KeyContainerName.Length > 260) { throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidKeyContainerName")); } _persistKeyInCSP = true; } } _parameters = parameters; } // // If no key spec has been specified, then set it to be // AT_KEYEXCHANGE, if a CALG_* has been specified, then // map that to AT_* value if (_parameters.KeyNumber == -1) { _parameters.KeyNumber = AT_KEYEXCHANGE; } else if (_parameters.KeyNumber == CALG_RSA_KEYX) { _parameters.KeyNumber = AT_KEYEXCHANGE; } else if (_parameters.KeyNumber == CALG_RSA_SIGN) { _parameters.KeyNumber = AT_SIGNATURE; } // See if we have the Enhanced RSA provider on this machine _hasEnhancedProvider = HasEnhancedProvider(); // Now determine legal key sizes. If AT_SIGNATURE, then 384 -- 16386. Otherwise, depends on // whether the strong provider is present. if (_parameters.KeyNumber == AT_SIGNATURE) { LegalKeySizesValue = new KeySizes[1] { new KeySizes(384, 16384, 8) }; } else if (_hasEnhancedProvider) { // it is, we have the strong provider LegalKeySizesValue = new KeySizes[1] { new KeySizes(384, 16384, 8) }; } else { // nope, all we have is the base provider LegalKeySizesValue = new KeySizes[1] { new KeySizes(384, 512, 8) }; // tone down the default key size _defaultKeySize = 512; } // Set the key size; this will throw an exception if dwKeySize is invalid. // Don't check if dwKeySize == 0, since that's the "default size", however // *our* default should be 1024 if the CSP can handle it. So, if the // key size was unspecified in a constructor to us, it'll be -1 here and // change it to the default size. If the user really put in a 0 give him back // the default for the CSP whatever it is. if (useDefaultKeySize) { dwKeySize = _defaultKeySize; } if (dwKeySize != 0) { KeySize = dwKeySize; } _dwKeySize = dwKeySize; // // Create the CSP container for this set of keys // _hCSP = IntPtr.Zero; _hKey = IntPtr.Zero; hr = _CreateCSP(_parameters, ref _hCSP); if (hr != 0) { throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_CouldNotAcquire")); } if (_hCSP == IntPtr.Zero) { throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_CouldNotAcquire")); } // If the key already exists, use it, else generate a new one hr = _GetUserKey(_hCSP, _parameters.KeyNumber, ref _hKey); if (hr != 0) { _hKey = _GenerateKey(_hCSP, _parameters.KeyNumber, dwKeySize << 16); if (_hKey == IntPtr.Zero) { throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_CreateKey")); } // We just gen'd a new key pair, so we have both halves. _containerContents = KeyContainerContents.PublicAndExportablePrivate; } else { // If the key already exists, make sure to persist it _persistKeyInCSP = true; // we have both halves, but we don't know if it's exportable or not _containerContents = KeyContainerContents.Unknown; } _CSPHandleProtector = new __CSPHandleProtector(_hCSP, _persistKeyInCSP, _parameters); _KeyHandleProtector = new __KeyHandleProtector(_hKey); }