protected void Schedule() { if (!this.isScheduled) { this.isScheduled = true; if (PartialTrustHelpers.ShouldFlowSecurityContext) { this.context = PartialTrustHelpers.CaptureSecurityContextNoIdentityFlow(); } if (this.context == null) { this.ScheduleCallback(ActionItem.CallbackHelper.InvokeWithoutContextCallback); return; } else { this.ScheduleCallback(ActionItem.CallbackHelper.InvokeWithContextCallback); return; } } else { throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.ActionItemIsAlreadyScheduled)); } }
internal ExecutionContext (ExecutionContext ec) { if (ec._sc != null) _sc = new SecurityContext (ec._sc); _suppressFlow = ec._suppressFlow; _capture = true; }
internal void Setup(SecurityContextDisableFlow flags) { this.useEC = false; this._sc = Thread.CurrentThread.ExecutionContext.SecurityContext; this._sc._disableFlow = flags; this._thread = Thread.CurrentThread; }
// copy constructor internal SecurityContext (SecurityContext sc) { _capture = true; _winid = sc._winid; if (sc._stack != null) _stack = sc._stack.CreateCopy (); }
internal ExecutionContext (ExecutionContext ec) { #if !NET_2_1 || MONOTOUCH if (ec._sc != null) _sc = new SecurityContext (ec._sc); #endif _suppressFlow = ec._suppressFlow; _capture = true; }
// copy constructor internal SecurityContext (SecurityContext sc) { _capture = true; #if !MOBILE _winid = sc._winid; if (sc._stack != null) _stack = sc._stack.CreateCopy (); #endif }
internal ExecutionContext (ExecutionContext ec) { #if !MOONLIGHT if (ec._sc != null) _sc = new SecurityContext (ec._sc); #endif _suppressFlow = ec._suppressFlow; _capture = true; }
private ExecutionContext (ExecutionContext ec) { #if !MOBILE if (ec._sc != null) _sc = new SecurityContext (ec._sc); #endif if (ec._lcc != null) _lcc = (LogicalCallContext) ec._lcc.Clone (); _suppressFlow = ec._suppressFlow; _capture = true; }
// static methods static public SecurityContext Capture () { SecurityContext sc = Thread.CurrentThread.ExecutionContext.SecurityContext; if (sc.FlowSuppressed) return null; SecurityContext capture = new SecurityContext (); capture._capture = true; capture._winid = WindowsIdentity.GetCurrentToken (); capture._stack = CompressedStack.Capture (); return capture; }
internal static ExecutionContextSwitcher SetExecutionContext(ExecutionContext executionContext) { StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller; ExecutionContextSwitcher switcher = new ExecutionContextSwitcher { thread = System.Threading.Thread.CurrentThread, prevEC = System.Threading.Thread.CurrentThread.GetExecutionContextNoCreate(), currEC = executionContext }; System.Threading.Thread.CurrentThread.SetExecutionContext(executionContext); RuntimeHelpers.PrepareConstrainedRegions(); try { if (executionContext == null) { return(switcher); } System.Security.SecurityContext securityContext = executionContext.SecurityContext; if (securityContext != null) { System.Security.SecurityContext prevSecurityContext = (switcher.prevEC != null) ? switcher.prevEC.SecurityContext : null; switcher.scsw = System.Security.SecurityContext.SetSecurityContext(securityContext, prevSecurityContext, ref lookForMyCaller); } else if (!System.Security.SecurityContext.CurrentlyInDefaultFTSecurityContext(switcher.prevEC)) { System.Security.SecurityContext context3 = (switcher.prevEC != null) ? switcher.prevEC.SecurityContext : null; switcher.scsw = System.Security.SecurityContext.SetSecurityContext(System.Security.SecurityContext.FullTrustSecurityContext, context3, ref lookForMyCaller); } System.Threading.SynchronizationContext synchronizationContext = executionContext.SynchronizationContext; if (synchronizationContext != null) { System.Threading.SynchronizationContext prevSyncContext = (switcher.prevEC != null) ? switcher.prevEC.SynchronizationContext : null; switcher.sysw = System.Threading.SynchronizationContext.SetSynchronizationContext(synchronizationContext, prevSyncContext); } System.Threading.HostExecutionContext hostExecutionContext = executionContext.HostExecutionContext; if (hostExecutionContext != null) { switcher.hecsw = HostExecutionContextManager.SetHostExecutionContextInternal(hostExecutionContext); } } catch { switcher.UndoNoThrow(); throw; } return(switcher); }
private void Dispose(bool disposing) { if (!this.disposed) { if (disposing) { this.DisposeCommands(); this.localPipeline = null; this.externalSuccessOutput = null; this.externalErrorOutput = null; this.executionScope = null; this.SecurityContext.Dispose(); this.SecurityContext = null; this.logBuffer = null; } this.disposed = true; } }
protected void Schedule() { if (isScheduled) { throw Fx.Exception.AsError(new InvalidOperationException(CommonResources.ActionItemIsAlreadyScheduled)); } this.isScheduled = true; if (PartialTrustHelpers.ShouldFlowSecurityContext) { this.context = PartialTrustHelpers.CaptureSecurityContextNoIdentityFlow(); } if (this.context != null) { ScheduleCallback(CallbackHelper.InvokeWithContextCallback); } else { ScheduleCallback(CallbackHelper.InvokeWithoutContextCallback); } }
internal static ExecutionContext Capture(ref StackCrawlMark stackMark, CaptureOptions options) { if (IsFlowSuppressed()) { return(null); } bool flag = CaptureOptions.None != (options & CaptureOptions.IgnoreSyncCtx); bool flag2 = CaptureOptions.None != (options & CaptureOptions.OptimizeDefaultCase); ExecutionContext executionContextNoCreate = System.Threading.Thread.CurrentThread.GetExecutionContextNoCreate(); System.Security.SecurityContext context2 = System.Security.SecurityContext.Capture(executionContextNoCreate, ref stackMark); System.Threading.HostExecutionContext context3 = HostExecutionContextManager.CaptureHostExecutionContext(); System.Threading.SynchronizationContext context4 = null; if ((executionContextNoCreate != null) && !flag) { context4 = (executionContextNoCreate._syncContext == null) ? null : executionContextNoCreate._syncContext.CreateCopy(); } System.Runtime.Remoting.Messaging.LogicalCallContext context5 = null; if (((executionContextNoCreate != null) && (executionContextNoCreate._logicalCallContext != null)) && executionContextNoCreate.LogicalCallContext.HasInfo) { context5 = (System.Runtime.Remoting.Messaging.LogicalCallContext)executionContextNoCreate.LogicalCallContext.Clone(); } if (((flag2 && (context2 == null)) && ((context3 == null) && (context4 == null))) && ((context5 == null) || !context5.HasInfo)) { return(s_dummyDefaultEC); } ExecutionContext context6 = new ExecutionContext { SecurityContext = context2 }; if (context6.SecurityContext != null) { context6.SecurityContext.ExecutionContext = context6; } context6._hostExecutionContext = context3; context6._syncContext = context4; context6.LogicalCallContext = context5; context6.isNewCapture = true; return(context6); }
protected void Schedule() { if (isScheduled) { throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.ActionItemIsAlreadyScheduled)); } this.isScheduled = true; #if FEATURE_COMPRESSEDSTACK if (PartialTrustHelpers.ShouldFlowSecurityContext) { this.context = PartialTrustHelpers.CaptureSecurityContextNoIdentityFlow(); } if (this.context != null) { ScheduleCallback(CallbackHelper.InvokeWithContextCallback); } else #endif { ScheduleCallback(CallbackHelper.InvokeWithoutContextCallback); } }
public bool IsSame(SecurityContext.Reader sc) { return m_sc == sc.m_sc; }
public bool IsSame(SecurityContext sc) { return m_sc == sc; }
[System.Security.SecuritySafeCritical] // auto-generated internal SecurityContext CreateMutableCopy() { Contract.Assert(!this.isNewCapture); SecurityContext sc = new SecurityContext(); sc._disableFlow = this._disableFlow; #if !FEATURE_PAL && FEATURE_IMPERSONATION if (this.WindowsIdentity != null) sc._windowsIdentity = new WindowsIdentity(this.WindowsIdentity.AccessToken); #endif //!FEATURE_PAL && FEATURE_IMPERSONATION // if (this._compressedStack != null) sc._compressedStack = this._compressedStack.CreateCopy(); return sc; }
[System.Security.SecurityCritical] // auto-generated static internal SecurityContext CreateFullTrustSecurityContext() { SecurityContext sc = new SecurityContext(); sc.isNewCapture = true; #if !FEATURE_PAL && FEATURE_IMPERSONATION if (IsWindowsIdentityFlowSuppressed()) { sc._disableFlow = SecurityContextDisableFlow.WI; } #endif // !FEATURE_PAL && FEATURE_IMPERSONATION #if FEATURE_COMPRESSEDSTACK // Force create CompressedStack sc.CompressedStack = new CompressedStack(null); #endif return sc; }
internal SecurityContextRunData(SecurityContext securityContext, ContextCallback cb, Object state) { this.sc = securityContext; this.callBack = cb; this.state = state; this.scsw = new SecurityContextSwitcher(); }
[HandleProcessCorruptedStateExceptions] // #endif // FEATURE_CORRUPTING_EXCEPTIONS internal static SecurityContextSwitcher SetSecurityContext(SecurityContext sc, SecurityContext.Reader prevSecurityContext, bool modifyCurrentExecutionContext, ref StackCrawlMark stackMark) { // Save the flow state at capture and reset it in the SC. SecurityContextDisableFlow _capturedFlowState = sc._disableFlow; sc._disableFlow = SecurityContextDisableFlow.Nothing; //Set up the switcher object SecurityContextSwitcher scsw = new SecurityContextSwitcher(); scsw.currSC = sc; scsw.prevSC = prevSecurityContext; if (modifyCurrentExecutionContext) { // save the current Execution Context ExecutionContext currEC = Thread.CurrentThread.GetMutableExecutionContext(); scsw.currEC = currEC; currEC.SecurityContext = sc; } if (sc != null) { RuntimeHelpers.PrepareConstrainedRegions(); try { #if !FEATURE_PAL && FEATURE_IMPERSONATION scsw.wic = null; if (!_LegacyImpersonationPolicy) { if (sc.WindowsIdentity != null) { scsw.wic = sc.WindowsIdentity.Impersonate(ref stackMark); } else if ( ((_capturedFlowState & SecurityContextDisableFlow.WI) == 0) && prevSecurityContext.WindowsIdentity != null) { // revert impersonation if there was no WI flow supression at capture and we're currently impersonating scsw.wic = WindowsIdentity.SafeRevertToSelf(ref stackMark); } } #endif scsw.cssw = CompressedStack.SetCompressedStack(sc.CompressedStack, prevSecurityContext.CompressedStack); } catch { scsw.UndoNoThrow(); throw; } } return scsw; }
public static bool IsWindowsIdentityFlowSuppressed() { return(_LegacyImpersonationPolicy || SecurityContext.IsFlowSuppressed(SecurityContextDisableFlow.WI)); }
internal void Setup(SecurityContextDisableFlow flags) { useEC = false; Thread currentThread = Thread.CurrentThread; _sc = currentThread.GetMutableExecutionContext().SecurityContext; _sc._disableFlow = flags; _thread = currentThread; }
static public void Run (SecurityContext securityContext, ContextCallback callback, object state) { if (securityContext == null) { throw new InvalidOperationException (Locale.GetText ( "Null SecurityContext")); } SecurityContext sc = Thread.CurrentThread.ExecutionContext.SecurityContext; IPrincipal original = Thread.CurrentPrincipal; try { if (sc.IdentityToken != IntPtr.Zero) { Thread.CurrentPrincipal = new WindowsPrincipal (new WindowsIdentity (sc.IdentityToken)); } // FIXME: is the security manager isn't active then we may not have // a compressed stack (bug #78652) if (securityContext.CompressedStack != null) CompressedStack.Run (securityContext.CompressedStack, callback, state); else callback (state); } finally { if ((original != null) && (sc.IdentityToken != IntPtr.Zero)) Thread.CurrentPrincipal = original; } }
static public void Run(SecurityContext securityContext, ContextCallback callback, object state) { callback(state); }
[System.Security.SecurityCritical] // auto-generated static internal SecurityContext Capture(ExecutionContext currThreadEC, ref StackCrawlMark stackMark) { // check to see if Flow is suppressed if (IsFlowSuppressed()) return null; // If we're in FT right now, return null if (CurrentlyInDefaultFTSecurityContext(currThreadEC)) return null; SecurityContext sc = new SecurityContext(); sc.isNewCapture = true; #if !FEATURE_PAL && FEATURE_IMPERSONATION // Force create WindowsIdentity if (!IsWindowsIdentityFlowSuppressed()) { WindowsIdentity currentIdentity = GetCurrentWI(currThreadEC); if (currentIdentity != null) sc._windowsIdentity = new WindowsIdentity(currentIdentity.TokenHandle); } else { sc._disableFlow = SecurityContextDisableFlow.WI; } #endif // !FEATURE_PAL && FEATURE_IMPERSONATION // Force create CompressedStack sc.CompressedStack = CompressedStack.GetCompressedStack(ref stackMark); return sc; }
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable internal static SecurityContextSwitcher SetSecurityContext(SecurityContext sc, SecurityContext prevSecurityContext) { StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; return SetSecurityContext(sc, prevSecurityContext, ref stackMark); }
protected void ScheduleWithContext(SecurityContext context) { if (context == null) { throw Fx.Exception.ArgumentNull("context"); } if (isScheduled) { throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.ActionItemIsAlreadyScheduled)); } this.isScheduled = true; this.context = context.CreateCopy(); ScheduleCallback(CallbackHelper.InvokeWithContextCallback); }
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable public static void Run(SecurityContext securityContext, ContextCallback callback, Object state) { if (securityContext == null ) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullContext")); } Contract.EndContractBlock(); StackCrawlMark stackMark = StackCrawlMark.LookForMe; if (!securityContext.isNewCapture) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext")); } securityContext.isNewCapture = false; #if !MOBILE ExecutionContext.Reader ec = Thread.CurrentThread.GetExecutionContextReader(); // Optimization: do the callback directly if both the current and target contexts are equal to the // default full-trust security context if ( SecurityContext.CurrentlyInDefaultFTSecurityContext(ec) && securityContext.IsDefaultFTSecurityContext()) { callback(state); if (GetCurrentWI(Thread.CurrentThread.GetExecutionContextReader()) != null) { // If we enter here it means the callback did an impersonation // that we need to revert. // We don't need to revert any other security state since it is stack-based // and automatically goes away when the callback returns. WindowsIdentity.SafeRevertToSelf(ref stackMark); // Ensure we have reverted to the state we entered in. Contract.Assert(GetCurrentWI(Thread.CurrentThread.GetExecutionContextReader()) == null); } } else #endif { RunInternal(securityContext, callback, state); } }
public static void Run(SecurityContext securityContext, ContextCallback callback, object state) { throw new NotSupportedException(); }
[System.Security.SecurityCritical] // auto-generated internal static void RunInternal(SecurityContext securityContext, ContextCallback callBack, Object state) { if (cleanupCode == null) { tryCode = new RuntimeHelpers.TryCode(runTryCode); cleanupCode = new RuntimeHelpers.CleanupCode(runFinallyCode); } SecurityContextRunData runData = new SecurityContextRunData(securityContext, callBack, state); RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(tryCode, cleanupCode, runData); }
public static bool IsFlowSuppressed() { return(SecurityContext.IsFlowSuppressed(SecurityContextDisableFlow.All)); }
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable internal static SecurityContextSwitcher SetSecurityContext(SecurityContext sc, SecurityContext.Reader prevSecurityContext, bool modifyCurrentExecutionContext) { StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; return SetSecurityContext(sc, prevSecurityContext, modifyCurrentExecutionContext, ref stackMark); }
public bool IsSame(SecurityContext sc) { return(m_sc == sc); }
[System.Security.SecuritySafeCritical] // auto-generated public SecurityContext CreateCopy() { if (!isNewCapture) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext")); } SecurityContext sc = new SecurityContext(); sc.isNewCapture = true; sc._disableFlow = _disableFlow; #if !FEATURE_PAL && FEATURE_IMPERSONATION if (WindowsIdentity != null) sc._windowsIdentity = new WindowsIdentity(WindowsIdentity.AccessToken); #endif //!FEATURE_PAL && FEATURE_IMPERSONATION if (_compressedStack != null) sc._compressedStack = _compressedStack.CreateCopy(); return sc; }
public Reader(SecurityContext sc) { m_sc = sc; }
[System.Security.SecurityCritical] // auto-generated static private SecurityContext CaptureCore(ExecutionContext.Reader currThreadEC, ref StackCrawlMark stackMark) { SecurityContext sc = new SecurityContext(); sc.isNewCapture = true; #if !FEATURE_PAL && FEATURE_IMPERSONATION // Force create WindowsIdentity if (!IsWindowsIdentityFlowSuppressed()) { WindowsIdentity currentIdentity = GetCurrentWI(currThreadEC); if (currentIdentity != null) sc._windowsIdentity = new WindowsIdentity(currentIdentity.AccessToken); } else { sc._disableFlow = SecurityContextDisableFlow.WI; } #endif // !FEATURE_PAL && FEATURE_IMPERSONATION // Force create CompressedStack sc.CompressedStack = CompressedStack.GetCompressedStack(ref stackMark); return sc; }
[HandleProcessCorruptedStateExceptions] // #endif // FEATURE_CORRUPTING_EXCEPTIONS public void Undo() { if (currSC == null) { return; // mutiple Undo()s called on this switcher object } if (currEC != null) { Contract.Assert(currEC == Thread.CurrentThread.GetMutableExecutionContext(), "SecurityContextSwitcher used from another thread"); Contract.Assert(currSC == currEC.SecurityContext, "SecurityContextSwitcher context mismatch"); // restore the saved security context currEC.SecurityContext = prevSC.DangerousGetRawSecurityContext(); } else { // caller must have already restored the ExecutionContext Contract.Assert(Thread.CurrentThread.GetExecutionContextReader().SecurityContext.IsSame(prevSC)); } currSC = null; // this will prevent the switcher object being used again bool bNoException = true; #if !FEATURE_PAL && FEATURE_IMPERSONATION try { if (wic != null) bNoException &= wic.UndoNoThrow(); } catch { // Failfast since we can't continue safely... bNoException &= cssw.UndoNoThrow(); System.Environment.FailFast(Environment.GetResourceString("ExecutionContext_UndoFailed")); } #endif bNoException &= cssw.UndoNoThrow(); if (!bNoException) { // Failfast since we can't continue safely... System.Environment.FailFast(Environment.GetResourceString("ExecutionContext_UndoFailed")); } }
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable internal static SecurityContextSwitcher SetSecurityContext(SecurityContext sc, SecurityContext.Reader prevSecurityContext, bool modifyCurrentExecutionContext) { StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; return(SetSecurityContext(sc, prevSecurityContext, modifyCurrentExecutionContext, ref stackMark)); }