// Token: 0x0600143B RID: 5179 RVA: 0x0004A334 File Offset: 0x00048534
private static void SendAuthenticationDataToWinRM(HttpContext httpContext, UserToken userToken)
{
WinRMInfo winRMInfo = httpContext.Items["X-RemotePS-WinRMInfo"] as WinRMInfo;
if (ProxySecurityContextModule.NeedSendDataToWinRM(winRMInfo))
{
userToken.UniformCommonAccessToken();
if (winRMInfo != null && "New-PSSession".Equals(winRMInfo.Action, StringComparison.OrdinalIgnoreCase))
{
HttpLogger.SafeAppendGenericInfo("WinRMCAT", userToken.GetReadableCommonAccessToken());
}
LatencyTracker latencyTracker = HttpContext.Current.Items["Logging-HttpRequest-Latency"] as LatencyTracker;
using (WinRMDataSender winRMDataSender = new WinRMDataSender(httpContext, latencyTracker))
{
winRMDataSender.SessionId = winRMInfo.FomattedSessionId;
if (HttpLogger.ActivityScope != null)
{
Guid activityId = HttpLogger.ActivityScope.ActivityId;
winRMDataSender.RequestId = HttpLogger.ActivityScope.ActivityId.ToString();
}
winRMDataSender.UserToken = userToken;
winRMDataSender.Send();
}
}
}
private void OnAuthenticateRequest(object source, EventArgs e)
{
HttpContext httpContext = HttpContext.Current;
if (!(httpContext.User.Identity is WindowsIdentity))
{
return;
}
WindowsIdentity windowsIdentity = (WindowsIdentity)httpContext.User.Identity;
if (windowsIdentity.User == null)
{
string value = string.Format("UnExpected: WindowsIdentity.User = null, AuthNType = {0}, Name = {1}", windowsIdentity.AuthenticationType, windowsIdentity.Name);
HttpLogger.SafeAppendGenericError("WindowsIdentityToGenericIdentityModule", value, true);
HttpApplication httpApplication = (HttpApplication)source;
httpContext.Response.StatusCode = 401;
httpApplication.CompleteRequest();
return;
}
ExAssert.RetailAssert(httpContext.User != null && httpContext.User.Identity != null && httpContext.User.Identity.Name != null, "HttpContext.User.Identity.Name should not be null.");
GenericIdentity identity = new GenericIdentity(httpContext.User.Identity.Name.ToLower(), "Converted-" + httpContext.User.Identity.AuthenticationType);
httpContext.User = new GenericPrincipal(identity, new string[0]);
using (WinRMDataSender winRMDataSender = new WinRMDataSender(httpContext, null))
{
WinRMInfo winRMInfo = httpContext.Items["X-RemotePS-WinRMInfo"] as WinRMInfo;
if (winRMInfo != null)
{
winRMDataSender.SessionId = winRMInfo.FomattedSessionId;
}
winRMDataSender.RequestId = HttpLogger.ActivityScope.ActivityId.ToString();
winRMDataSender.UserToken = new UserToken(AuthenticationType.Kerberos, null, null, windowsIdentity.Name, windowsIdentity.User, null, OrganizationId.ForestWideOrgId, null, false, new CommonAccessToken(windowsIdentity));
winRMDataSender.Send();
}
}
private void ReviseAction(string funcName)
{
ExTraceGlobals.HttpModuleTracer.TraceFunction <string>((long)this.GetHashCode(), "[PingDetectionModule::{0}] Enter", funcName);
HttpContext httpContext = HttpContext.Current;
HttpResponse response = httpContext.Response;
if (response == null)
{
return;
}
if (httpContext.Items["ActionHasBeenRevised"] != null)
{
return;
}
httpContext.Items["ActionHasBeenRevised"] = "Y";
WinRMInfo winRMInfoFromHttpHeaders = WinRMInfo.GetWinRMInfoFromHttpHeaders(httpContext.Request.Headers);
string text;
if (WinRMRequestTracker.TryReviseAction(winRMInfoFromHttpHeaders, response.StatusCode, response.SubStatusCode, out text))
{
HttpLogger.SafeSetLogger(RpsHttpMetadata.Action, text);
string headerValue = "Ping".Equals(text) ? "Ping" : "Non-Ping";
this.SafeSetResponseHeader(response, "X-RemotePS-Ping", headerValue);
this.SafeSetResponseHeader(response, "X-RemotePS-RevisedAction", text);
}
ExTraceGlobals.HttpModuleTracer.TraceFunction <string>((long)this.GetHashCode(), "[PingDetectionModule::{0}] Exit.", funcName);
}
// Token: 0x0600000C RID: 12 RVA: 0x000022C8 File Offset: 0x000004C8
private void OnAuthenticateRequest(object source, EventArgs args)
{
Logger.EnterFunction(ExTraceGlobals.RemotePowershellBackendCmdletProxyModuleTracer, "OnAuthenticateOrPostAuthenticateRequest");
HttpContext httpContext = HttpContext.Current;
if (httpContext.Request.IsAuthenticated)
{
Logger.TraceDebug(ExTraceGlobals.RemotePowershellBackendCmdletProxyModuleTracer, "[RemotePowershellBackendCmdletProxyModule::OnAuthenticateOrPostAuthenticateRequest] Current authenticated user is {0} of type {1}.", new object[]
{
httpContext.User.Identity,
httpContext.User.Identity.GetType()
});
string value = httpContext.Request.Headers["X-CommonAccessToken"];
if (string.IsNullOrEmpty(value))
{
Uri url = httpContext.Request.Url;
Exception ex = null;
CommonAccessToken commonAccessToken = RemotePowershellBackendCmdletProxyModule.CommonAccessTokenFromUrl(httpContext.User.Identity.ToString(), url, out ex);
if (ex != null)
{
WinRMInfo.SetFailureCategoryInfo(httpContext.Response.Headers, FailureCategory.BackendCmdletProxy, ex.GetType().Name);
httpContext.Response.StatusCode = 500;
httpContext.ApplicationInstance.CompleteRequest();
}
else if (commonAccessToken != null)
{
httpContext.Request.Headers["X-CommonAccessToken"] = commonAccessToken.Serialize();
Logger.TraceDebug(ExTraceGlobals.RemotePowershellBackendCmdletProxyModuleTracer, "[RemotePowershellBackendCmdletProxyModule::OnAuthenticateOrPostAuthenticateRequest] The CommonAccessToken has been successfully stampped in request HTTP header.", new object[0]);
}
}
}
Logger.ExitFunction(ExTraceGlobals.RemotePowershellBackendCmdletProxyModuleTracer, "OnAuthenticateOrPostAuthenticateRequest");
}
internal static string GetDiagnosticsInfo(HttpContext context)
{
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(context);
Guid guid = Guid.Empty;
IActivityScope activityScope = null;
if (current != null)
{
guid = current.ActivityId;
activityScope = current.ActivityScope;
}
string text = string.Format("[ClientAccessServer={0},BackEndServer={1},RequestId={2},TimeStamp={3}] ", new object[]
{
Environment.MachineName,
(activityScope == null) ? "UnKown" : activityScope.GetProperty(HttpProxyMetadata.TargetServer),
guid,
DateTime.UtcNow
});
string text2 = string.Empty;
if (context != null)
{
text2 = WinRMInfo.GetFailureCategoryInfo(context);
}
if (!string.IsNullOrEmpty(text2))
{
text += string.Format("[FailureCategory={0}] ", text2);
}
ExTraceGlobals.VerboseTracer.TraceDebug <string>(0L, "[WinRMHelper::GetDiagnosticsInfo] diagnosticsInfo = {0}.", text);
return(text);
}
// Token: 0x060006F3 RID: 1779 RVA: 0x00028E60 File Offset: 0x00027060
protected override void ExposeExceptionToClientResponse(Exception ex)
{
if (!WinRMHelper.FriendlyErrorEnabled.Value)
{
base.ExposeExceptionToClientResponse(ex);
return;
}
if (ex is WebException)
{
WebException ex2 = (WebException)ex;
if (WinRMHelper.IsPingRequest(ex2))
{
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[RemotePowerShellProxyRequestHandler::ExposeExceptionToClientResponse]: Context={0}, Ping found.", base.TraceContext);
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(base.Logger, 21, "Ping");
base.ClientResponse.Headers["X-RemotePS-Ping"] = "Ping";
return;
}
if (WinRMHelper.CouldBePingRequest(ex2))
{
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[RemotePowerShellProxyRequestHandler::ExposeExceptionToClientResponse]: Context={0}, Could be Ping request.", base.TraceContext);
}
base.ClientResponse.Headers["X-RemotePS-Ping"] = "Possible-Ping";
return;
}
if (ex2.Status != WebExceptionStatus.ProtocolError)
{
WinRMInfo.SetFailureCategoryInfo(base.ClientResponse.Headers, 3, ex2.Status.ToString());
}
if (ex2.Response != null)
{
string text = ex2.Response.Headers["X-BasicAuthToOAuthConversionDiagnostics"];
if (!string.IsNullOrWhiteSpace(text))
{
base.ClientResponse.Headers["X-BasicAuthToOAuthConversionDiagnostics"] = text + " ";
}
}
}
if (ex is HttpProxyException && !string.IsNullOrWhiteSpace(ex.Message) && !WinRMHelper.DiagnosticsInfoHasBeenWritten(base.ClientResponse.Headers))
{
WinRMInfo.SetFailureCategoryInfo(base.ClientResponse.Headers, 3, ex.GetType().Name);
string diagnosticsInfo = WinRMHelper.GetDiagnosticsInfo(base.HttpContext);
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int, string>((long)this.GetHashCode(), "[RemotePowerShellProxyRequestHandler::ExposeExceptionToClientResponse]: Context={0}, Write Message {1} to client response.", base.TraceContext, ex.Message);
}
WinRMHelper.SetDiagnosticsInfoWrittenFlag(base.ClientResponse.Headers);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(base.Logger, "FriendlyError", "ExposeException");
base.ClientResponse.Write(diagnosticsInfo + ex.Message);
return;
}
base.ExposeExceptionToClientResponse(ex);
}
// Token: 0x060006ED RID: 1773 RVA: 0x000287E3 File Offset: 0x000269E3
protected override void ResetForRetryOnError()
{
if (base.ClientResponse != null && base.ClientResponse.Headers != null)
{
WinRMInfo.ClearFailureCategoryInfo(base.ClientResponse.Headers);
}
base.ResetForRetryOnError();
}
// Token: 0x06001439 RID: 5177 RVA: 0x0004A0D8 File Offset: 0x000482D8
private void OnAuthenticateRequest(object source, EventArgs e)
{
ExTraceGlobals.AccessCheckTracer.TraceDebug(0L, "Start OnAuthenticateRequest");
HttpApplication httpApplication = (HttpApplication)source;
HttpContext context = httpApplication.Context;
UserToken userToken = context.CurrentUserToken();
if (this.IsDelegatedAuth(context))
{
ExTraceGlobals.AccessCheckTracer.TraceDebug(0L, "Delegated auth, let delegated auth module handle the request");
}
else
{
if (context.Request.IsAuthenticated && userToken.HasCommonAccessToken)
{
try
{
if (userToken.HasCommonAccessToken && ProxySecurityContextModule.AuthenticationTypes.ContainsKey(userToken.AuthenticationType))
{
string text = ProxySecurityContextModule.AuthenticationTypes[userToken.AuthenticationType];
if (context.User != null && context.User.Identity != null)
{
context.Items["AuthType"] = context.User.Identity.AuthenticationType;
if (!context.Items.Contains("AuthenticatedUser"))
{
context.Items["AuthenticatedUser"] = context.User.Identity.Name;
}
else
{
HttpLogger.SafeAppendGenericInfo("User.Identity", context.User.Identity.Name);
}
}
ExTraceGlobals.AccessCheckTracer.TraceDebug <AuthenticationType, string>(0L, "Token Type = {0}, AuthenticationType = {1}.", userToken.AuthenticationType, text);
ExAssert.RetailAssert(context.User != null && context.User.Identity != null && context.User.Identity.Name != null, "HttpContext.User.Identity.Name should not be null.");
GenericIdentity identity = new GenericIdentity(context.User.Identity.Name.ToLower(), text);
context.User = new GenericPrincipal(identity, new string[0]);
ProxySecurityContextModule.SendAuthenticationDataToWinRM(context, userToken);
}
goto IL_201;
}
catch (Exception ex)
{
HttpModuleHelper.EndPowerShellRequestWithFriendlyError(context, FailureCategory.ProxySecurityContext, "Exception", ex.ToString(), "ProxySecurityContextModule", KnownException.IsUnhandledException(ex));
goto IL_201;
}
}
ExTraceGlobals.AccessCheckTracer.TraceDebug(0L, "Request is Unauthorized.");
WinRMInfo.SetFailureCategoryInfo(context.Response.Headers, FailureCategory.ProxySecurityContext, "Unauthorized");
context.Response.StatusCode = 401;
httpApplication.CompleteRequest();
}
IL_201:
ExTraceGlobals.AccessCheckTracer.TraceDebug(0L, "Exit OnAuthenticateRequest");
}
// Token: 0x0600148C RID: 5260 RVA: 0x0004CC08 File Offset: 0x0004AE08
internal static string GetIdentityForWinRMAPI(string originalIdentity, WinRMInfo winRMInfo)
{
if (winRMInfo == null || string.IsNullOrEmpty(winRMInfo.FomattedSessionId))
{
return(originalIdentity);
}
return(string.Concat(new object[]
{
"908C5F03-5125-46BF-8746-A47994D0DA77",
winRMInfo.FomattedSessionId,
',',
originalIdentity
}));
}
// Token: 0x0600046E RID: 1134 RVA: 0x00018BF0 File Offset: 0x00016DF0
internal static string GetDiagnosticsInfo(HttpContext context)
{
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(context);
Guid guid = Guid.Empty;
IActivityScope activityScope = null;
if (current != null)
{
guid = current.ActivityId;
activityScope = current.ActivityScope;
}
string text = string.Format("[ClientAccessServer={0},BackEndServer={1},RequestId={2},TimeStamp={3}] ", new object[]
{
Environment.MachineName,
(activityScope == null) ? "UnKnown" : activityScope.GetProperty(13),
guid,
DateTime.UtcNow
});
string text2 = string.Empty;
if (context != null)
{
text2 = WinRMInfo.GetFailureCategoryInfo(context);
}
if (!string.IsNullOrEmpty(text2))
{
text += string.Format("[FailureCategory={0}] ", text2);
}
string text3 = context.Response.Headers["X-BasicAuthToOAuthConversionDiagnostics"];
if (!string.IsNullOrWhiteSpace(text3))
{
text += string.Format("BasicAuthToOAuthConversionDiagnostics={0}", text3);
}
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <string>(0L, "[WinRMHelper::GetDiagnosticsInfo] diagnosticsInfo = {0}.", text);
}
return(text);
}
// Token: 0x06000380 RID: 896 RVA: 0x00013F04 File Offset: 0x00012104
private bool TryGetUpdatedBufferToSend(ArraySegment <byte> buffer, out byte[] updatedBuffer, out string failureHint)
{
HttpContext context = base.RequestContext.HttpContext;
updatedBuffer = null;
failureHint = null;
if (context.Response == null)
{
failureHint = "Response Null";
return(false);
}
int statusCode = context.Response.StatusCode;
if (statusCode < 400)
{
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int, int>((long)this.GetHashCode(), "[RpsOutDataResponseStreamProxy::TryGetUpdatedBufferToSend] Context={0}, StatusCode={1}.", base.RequestContext.TraceContext, statusCode);
}
return(false);
}
if (WinRMHelper.DiagnosticsInfoHasBeenWritten(context.Response.Headers))
{
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[RpsOutDataResponseStreamProxy::TryGetUpdatedBufferToSend] Context={0}, diagnostics info has been written.", base.RequestContext.TraceContext);
}
failureHint = "BeenWritten";
return(false);
}
if (WinRMHelper.TryInsertDiagnosticsInfo(buffer, () => WinRMHelper.GetDiagnosticsInfo(context), out updatedBuffer, out failureHint, delegate(string winRMFaultMessage)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(this.RequestContext.Logger, "WinRMFaultMessage", winRMFaultMessage);
WinRMInfo.SetWSManFailureCategory(context.Response.Headers, winRMFaultMessage);
}))
{
WinRMHelper.SetDiagnosticsInfoWrittenFlag(context.Response.Headers);
return(true);
}
return(false);
}
private void OnEndRequest(object sender, EventArgs e)
{
HttpContext context = ((HttpApplication)sender).Context;
HttpResponse response = context.Response;
WinRMInfo winRMInfoFromHttpHeaders = WinRMInfo.GetWinRMInfoFromHttpHeaders(context.Request.Headers);
string text = (winRMInfoFromHttpHeaders != null) ? winRMInfoFromHttpHeaders.SessionUniqueId : null;
if (response == null || winRMInfoFromHttpHeaders == null || text == null)
{
return;
}
if ("Remove-PSSession".Equals(winRMInfoFromHttpHeaders.Action, StringComparison.OrdinalIgnoreCase))
{
RpsHttpDatabaseValidationModule.ActiveSessionCache.Remove(text);
return;
}
if (response.StatusCode == 200 && !RpsHttpDatabaseValidationModule.ActiveSessionCache.Contains(text))
{
RpsHttpDatabaseValidationModule.ActiveSessionCache.TryInsertSliding(text, 0, RpsHttpDatabaseValidationModule.SlidingTimeSpanForActiveSession);
}
}
private void OnPostAuthenticateRequest(object sender, EventArgs e)
{
HttpContextBase context = new HttpContextWrapper(((HttpApplication)sender).Context);
WinRMInfo winRMInfoFromHttpHeaders = WinRMInfo.GetWinRMInfoFromHttpHeaders(context.Request.Headers);
if (winRMInfoFromHttpHeaders != null)
{
string sessionUniqueId = winRMInfoFromHttpHeaders.SessionUniqueId;
int num = 0;
if (!string.IsNullOrEmpty(sessionUniqueId) && RpsHttpDatabaseValidationModule.ActiveSessionCache.TryGetValue(sessionUniqueId, out num))
{
HttpLogger.SafeAppendGenericInfo("CachedSessionId", sessionUniqueId);
return;
}
}
using (new MonitoredScope("RpsHttpDatabaseValidationModule", "RpsHttpDatabaseValidationModule", HttpModuleHelper.HttpPerfMonitors))
{
HttpDatabaseValidationHelper.ValidateHttpDatabaseHeader(context, delegate
{
}, delegate(string routingError)
{
if (context.Request.Headers[WellKnownHeader.XCafeLastRetryHeaderKey] != null)
{
HttpLogger.SafeAppendGenericInfo("IgnoreRoutingError", "Cafe last retry");
return;
}
HttpLogger.SafeAppendGenericError("ServerRoutingError", routingError, false);
WinRMInfo.SetFailureCategoryInfo(context.Response.Headers, FailureCategory.DatabaseValidation, "ServerRoutingError");
this.SendErrorResponse(context, 555, 0, routingError, delegate(HttpResponseBase response)
{
response.Headers[WellKnownHeader.BEServerRoutingError] = routingError;
}, false);
}, delegate
{
HttpLogger.SafeAppendGenericError("InvalidMailboxDatabaseGuid", "Cannot Parse MailboxDatabaseGuid From Header", false);
WinRMInfo.SetFailureCategoryInfo(context.Response.Headers, FailureCategory.DatabaseValidation, "InvalidDatabaseGuid");
this.SendErrorResponse(context, 400, 0, "Invalid database guid", null, false);
});
}
}
private static void ReportCustomError(HttpResponse response, HttpStatusCode status, int subStatus, string errorMessage)
{
Logger.LogVerbose("Reporting HTTP error: Status - {0}, SubStatus - {1}, Message - {2}", new object[]
{
status,
subStatus,
errorMessage
});
string fcSubInfo = "Unknown";
if (subStatus != 102)
{
switch (subStatus)
{
case 200:
fcSubInfo = "UnknownInternalError";
break;
case 201:
fcSubInfo = "TransientServerError";
break;
}
}
else
{
fcSubInfo = "UserNotFound";
}
WinRMInfo.SetFailureCategoryInfo(response.Headers, FailureCategory.Certificate, fcSubInfo);
response.Clear();
response.StatusCode = (int)status;
response.SubStatusCode = subStatus;
response.ContentType = "application/soap+xml;charset=UTF-8";
response.TrySkipIisCustomErrors = true;
if (!string.IsNullOrEmpty(errorMessage))
{
response.Write(errorMessage);
}
response.End();
}
// Token: 0x060006EF RID: 1775 RVA: 0x00028A04 File Offset: 0x00026C04
protected override bool ShouldCopyHeaderToServerRequest(string headerName)
{
return(!string.Equals(headerName, "X-RemotePS-GenericIdentity", StringComparison.OrdinalIgnoreCase) && !string.Equals(headerName, "X-RemotePS-WindowsIdentity", StringComparison.OrdinalIgnoreCase) && !string.Equals(headerName, "msExchCafeForceRouteToLogonAccount", StringComparison.OrdinalIgnoreCase) && !string.Equals(headerName, "X-DatabaseGuid", StringComparison.OrdinalIgnoreCase) && !string.Equals(headerName, "X-Cafe-Last-Retry", StringComparison.OrdinalIgnoreCase) && !WinRMInfo.IsHeaderReserverd(headerName) && base.ShouldCopyHeaderToServerRequest(headerName));
}
// Token: 0x060000D4 RID: 212 RVA: 0x00005FE8 File Offset: 0x000041E8
private void OnBeginRequest(object sender, EventArgs e)
{
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[LoggingStartModule::OnBeginRequest] Enter");
LatencyTracker latencyTracker = new LatencyTracker(Constants.IsPowerShellWebService ? "Psws.HttpModule" : "Rps.HttpModule", null);
latencyTracker.Start();
HttpContext httpContext = HttpContext.Current;
HttpRequest request = httpContext.Request;
NameValueCollection headers = httpContext.Request.Headers;
httpContext.Items["Logging-HttpRequest-Latency"] = latencyTracker;
HttpLogger.InitializeRequestLogger();
if (HttpLogger.ActivityScope != null)
{
HttpLogger.ActivityScope.UpdateFromMessage(HttpContext.Current.Request);
HttpLogger.ActivityScope.SerializeTo(HttpContext.Current.Response);
}
if (Constants.IsRemotePS && HttpLogger.ActivityScope != null && request.Url.Port == 444)
{
Uri url = request.Url;
NameValueCollection urlProperties = url.GetUrlProperties();
string text = urlProperties["RequestId48CD6591-0506-4D6E-9131-797489A3260F"];
Guid guid;
if (text != null && Guid.TryParse(text, out guid))
{
LoggerHelper.UpdateActivityScopeRequestIdFromUrl(url.ToString());
}
}
HttpLogger.SafeSetLogger(ServiceCommonMetadata.HttpMethod, request.HttpMethod);
WinRMInfo winRMInfoFromHttpHeaders = WinRMInfo.GetWinRMInfoFromHttpHeaders(headers);
if (winRMInfoFromHttpHeaders != null)
{
HttpLogger.SafeSetLogger(RpsHttpMetadata.Action, winRMInfoFromHttpHeaders.Action);
HttpLogger.SafeSetLogger(RpsCommonMetadata.SessionId, winRMInfoFromHttpHeaders.SessionId);
HttpLogger.SafeSetLogger(RpsHttpMetadata.ShellId, winRMInfoFromHttpHeaders.ShellId);
HttpLogger.SafeSetLogger(RpsHttpMetadata.CommandId, winRMInfoFromHttpHeaders.CommandId);
HttpLogger.SafeSetLogger(RpsHttpMetadata.CommandName, winRMInfoFromHttpHeaders.CommandName);
httpContext.Items["X-RemotePS-WinRMInfo"] = winRMInfoFromHttpHeaders;
}
string sourceCafeServer = CafeHelper.GetSourceCafeServer(request);
if (sourceCafeServer != null)
{
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.FrontEndServer, sourceCafeServer);
}
Uri url2 = request.Url;
if (url2.IsAbsoluteUri)
{
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.UrlHost, url2.DnsSafeHost);
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.UrlStem, url2.LocalPath);
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.UrlQuery, url2.Query);
}
else
{
HttpLogger.SafeAppendGenericError("InvalidRelativeUri", url2.ToString(), false);
}
NameValueCollection urlProperties2 = url2.GetUrlProperties();
if (urlProperties2 != null)
{
string text2;
if (!string.IsNullOrWhiteSpace(text2 = urlProperties2["Organization"]))
{
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.ManagedOrganization, text2);
}
else if (!string.IsNullOrWhiteSpace(text2 = urlProperties2["DelegatedOrg"]))
{
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.ManagedOrganization, "Delegate:" + text2);
}
}
if (HttpLogger.ActivityScope != null)
{
using (new MonitoredScope("RequestMonitor.Register", "RequestMonitor.Register", HttpModuleHelper.HttpPerfMonitors))
{
RequestMonitor.Instance.RegisterRequest(HttpLogger.ActivityScope.ActivityId);
string text3 = headers[WellKnownHeader.WLIDMemberName] ?? headers[WellKnownHeader.LiveIdMemberName];
if (!string.IsNullOrEmpty(text3))
{
SmtpAddress smtpAddress = new SmtpAddress(text3);
RequestMonitor.Instance.Log(HttpLogger.ActivityScope.ActivityId, RequestMonitorMetadata.AuthenticatedUser, text3);
RequestMonitor.Instance.Log(HttpLogger.ActivityScope.ActivityId, RequestMonitorMetadata.Organization, smtpAddress.Domain);
}
RequestMonitor.Instance.Log(HttpLogger.ActivityScope.ActivityId, RequestMonitorMetadata.FrontEndServer, sourceCafeServer);
RequestMonitor.Instance.Log(HttpLogger.ActivityScope.ActivityId, RequestMonitorMetadata.ProtocolAction, HttpLogger.ActivityScope.GetProperty(RpsHttpMetadata.Action));
}
}
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[LoggingStartModule::OnBeginRequest] Exit");
}
private void ThrottleRequest(HttpContext context)
{
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[ThrottlingHttpModule::ThrottleRequest] Enter");
WinRMInfo winRMInfo = context.Items["X-RemotePS-WinRMInfo"] as WinRMInfo;
if (winRMInfo == null)
{
ExTraceGlobals.HttpModuleTracer.TraceDebug((long)this.GetHashCode(), "[ThrottlingHttpModule::ThrottleRequest] WinRMInfo = null.");
return;
}
string action = winRMInfo.Action;
if (string.IsNullOrEmpty(action))
{
ExTraceGlobals.HttpModuleTracer.TraceDebug((long)this.GetHashCode(), "[ThrottlingHttpModule::ThrottleRequest] WinRMInfo.Action = null.");
return;
}
if (!action.EndsWith(":Command", StringComparison.OrdinalIgnoreCase) && !action.Equals("Command", StringComparison.OrdinalIgnoreCase))
{
ExTraceGlobals.HttpModuleTracer.TraceDebug <string>((long)this.GetHashCode(), "[ThrottlingHttpModule::ThrottleRequest] Not Command Request. WinRMInfo.Action = {0}.", action);
return;
}
IPowerShellBudget powerShellBudget = null;
OverBudgetException ex = null;
try
{
try
{
using (new MonitoredScope("ThrottlingHttpModule", "GetBudget", HttpModuleHelper.HttpPerfMonitors))
{
powerShellBudget = this.GetBudget(context);
}
if (powerShellBudget == null)
{
ExTraceGlobals.HttpModuleTracer.TraceDebug((long)this.GetHashCode(), "[ThrottlingHttpModule::ThrottleRequest] budget = null.");
return;
}
using (new MonitoredScope("ThrottlingHttpModule", "CheckBudgetAndStartCmdlet", HttpModuleHelper.HttpPerfMonitors))
{
powerShellBudget.StartCmdlet(null);
powerShellBudget.TryCheckOverBudget(CostType.CMDLET, out ex);
}
}
finally
{
if (powerShellBudget != null)
{
powerShellBudget.Dispose();
}
}
if (ex != null)
{
string windowsLiveId = context.CurrentUserToken().WindowsLiveId;
if (windowsLiveId != null)
{
FailFastUserCache.Instance.AddUserToCache(windowsLiveId, BlockedType.NewRequest, TimeSpan.Zero);
HttpLogger.SafeAppendColumn(RpsCommonMetadata.ContributeToFailFast, "AuthZ-UserSelf", LoggerHelper.GetContributeToFailFastValue("User", windowsLiveId, BlockedType.NewRequest.ToString(), -1.0));
}
HttpModuleHelper.EndPowerShellRequestWithFriendlyError(context, FailureCategory.AuthZ, ex.GetType().Name, Strings.ErrorOperationTarpitting(ex.BackoffTime / 1000) + string.Format("{2}Policy: {0}; {2}Snapshot: {1}", ex.ThrottlingPolicyDN, ex.Snapshot, Environment.NewLine), "ThrottlingHttpModule", false);
}
}
catch (Exception ex2)
{
if (!(ex2 is ThreadAbortException))
{
HttpLogger.SafeAppendGenericError("ThrottlingHttpModule", ex2, new Func <Exception, bool>(KnownException.IsUnhandledException));
ExTraceGlobals.HttpModuleTracer.TraceError <Exception>((long)this.GetHashCode(), "[ThrottlingHttpModule::ThrottleRequest] Get un-Excpected Exception. {0}", ex2);
}
}
}
internal bool TryParseStream(Stream stream, out WinRMInfo winRMInfo, out string failureHint)
{
failureHint = null;
winRMInfo = null;
if (stream == null)
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[WinRMParser::TryParseStream] Context={0}, stream = null.", this.TraceContext);
failureHint = "Stream = null";
return(false);
}
bool result;
try
{
byte[] array = new byte[10000];
int num = stream.Read(array, 0, array.Length);
if (num <= 0)
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[WinRMParser::TryParseStream] Context={0}, bytesRead <= 0", this.TraceContext);
failureHint = "BytesRead <= 0";
result = false;
}
else
{
string @string = Encoding.UTF8.GetString(array, 0, Math.Min(num, WinRMHelper.MaxBytesToPeekIntoRequestStream.Value));
string text = null;
string text2 = null;
string text3 = null;
string text4 = null;
string commandName = null;
string text5 = null;
int num2 = 0;
this.TryMatch(@string, WinRMParser.actionRegex, "action", ref num2, out text);
if (text == null)
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[WinRMParser::TryParseStream] No Action found in the input string", this.TraceContext);
failureHint = "RawAction = null";
result = false;
}
else
{
this.TryMatch(@string, WinRMParser.sessionIdRegx, "sessionId", ref num2, out text2);
if (text2 == null)
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[WinRMParser::TryParseStream] No SessionId found in the input string", this.TraceContext);
}
else if (text2.StartsWith("uuid:"))
{
text2 = text2.Substring(5);
}
this.TryMatch(@string, WinRMParser.shellIdRegx, "shellId", ref num2, out text3);
if (text3 == null && !"http://schemas.xmlsoap.org/ws/2004/09/transfer/Create".Equals(text, StringComparison.OrdinalIgnoreCase))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[WinRMParser::TryParseStream] No ShellId found in the input string and the current action is " + text, this.TraceContext);
failureHint = "ShellId = null";
result = false;
}
else
{
this.TryMatch(@string, WinRMParser.commandIdRegx, "commandId", ref num2, out text4);
if (text4 != null)
{
this.TryMatch(@string, WinRMParser.commandNameRegx, "commandName", ref num2, out commandName);
}
if ("http://schemas.microsoft.com/wbem/wsman/1/windows/shell/Signal".Equals(text, StringComparison.OrdinalIgnoreCase))
{
this.TryMatch(@string, WinRMParser.signalCodeRegex, "signalCode", ref num2, out text5);
}
string text6 = this.GenerateUserFriendlyAction(text, text4, commandName, text5);
this.UpdateCommandIdToCommandNameCache(text, text4, commandName, text5);
ExTraceGlobals.VerboseTracer.TraceDebug((long)this.GetHashCode(), "[WinRMParser::TryParseStream] Context={0}, Action=\"{1}\", RawAction=\"{2}\", SessionId=\"{3}\", ShellId=\"{4}\", CommandId=\"{5}\", SignalCode=\"{6}\".", new object[]
{
this.TraceContext,
text6,
text,
text2,
text3,
text4,
text5
});
winRMInfo = new WinRMInfo
{
Action = text6,
RawAction = text,
SessionId = text2,
ShellId = text3,
CommandId = text4,
CommandName = commandName,
SignalCode = text5
};
result = true;
}
}
}
}
catch (Exception ex)
{
Diagnostics.ReportException(ex, FrontEndHttpProxyEventLogConstants.Tuple_InternalServerError, null, "Exception from WinRMParser::TryParseStream event: {0}");
failureHint = ex.ToString();
result = false;
}
return(result);
}
// Token: 0x0600143C RID: 5180 RVA: 0x0004A418 File Offset: 0x00048618
private static bool NeedSendDataToWinRM(WinRMInfo winRMInfo)
{
return(winRMInfo == null || string.IsNullOrEmpty(winRMInfo.Action) || winRMInfo.Action.Equals("New-PSSession", StringComparison.OrdinalIgnoreCase));
}
// Token: 0x060000F6 RID: 246 RVA: 0x00006C50 File Offset: 0x00004E50
internal static bool TryReviseAction(WinRMInfo winRMInfo, int status, int subStatus, out string revisedAction)
{
ExTraceGlobals.HttpModuleTracer.TraceFunction(0L, "[WinRMRequestTracker::TryReviseAction] Enter");
revisedAction = null;
if (status == 500 && subStatus == 687)
{
ExTraceGlobals.HttpModuleTracer.TraceDebug <int, int>(0L, "[WinRMRequestTracker::TryReviseAction] Ping detected. Status = {0} SubStatus = {1}", status, subStatus);
revisedAction = "Ping";
return(true);
}
if (winRMInfo == null)
{
ExTraceGlobals.HttpModuleTracer.TraceDebug(0L, "[WinRMRequestTracker::TryReviseAction] winRMInfo = null.");
return(false);
}
string text = winRMInfo.SessionId ?? winRMInfo.ShellId;
if (string.IsNullOrEmpty(text))
{
return(false);
}
string action = winRMInfo.Action;
if ("Remove-PSSession".Equals(action))
{
ExTraceGlobals.HttpModuleTracer.TraceDebug <string>(0L, "[WinRMRequestTracker::TryReviseAction] End tracking session {0} in cache.", text);
WinRMRequestTracker.SessionIdToStateCache.InsertSliding(text, 20, WinRMRequestTracker.SlidingTimeSpanAfterRemoveSession, null);
return(false);
}
if ("New-PSSession".Equals(action) || ("Receive".Equals(action) && !WinRMRequestTracker.SessionIdToStateCache.Contains(text)))
{
ExTraceGlobals.HttpModuleTracer.TraceDebug <string>(0L, "[WinRMRequestTracker::TryReviseAction] Start tracking session {0} in cache.", text);
WinRMRequestTracker.SessionIdToStateCache.InsertSliding(text, 0, WinRMRequestTracker.SlidingTimeSpan, null);
}
string commandId = winRMInfo.CommandId;
if (!string.IsNullOrEmpty(commandId))
{
int num;
if (WinRMRequestTracker.SessionIdToStateCache.TryGetValue(text, out num) && num != 10)
{
ExTraceGlobals.HttpModuleTracer.TraceDebug <string>(0L, "[WinRMRequestTracker::TryReviseAction] Change session {0} state to command in cache.", text);
WinRMRequestTracker.SessionIdToStateCache.InsertSliding(text, 10, WinRMRequestTracker.SlidingTimeSpan, null);
}
if (!string.IsNullOrEmpty(action) && action.EndsWith("Terminate"))
{
bool result = false;
string arg;
if ("Terminate".Equals(action) && WinRMRequestTracker.CommandIdToCommandNameCache.TryGetValue(commandId, out arg))
{
revisedAction = arg + ':' + "Terminate";
result = true;
}
ExTraceGlobals.HttpModuleTracer.TraceDebug <string>(0L, "[WinRMRequestTracker::TryReviseAction] End tracking command {0} in cache.", commandId);
WinRMRequestTracker.CommandIdToCommandNameCache.Remove(commandId);
return(result);
}
if (!string.IsNullOrEmpty(winRMInfo.CommandName) && !WinRMRequestTracker.CommandIdToCommandNameCache.Contains(commandId))
{
ExTraceGlobals.HttpModuleTracer.TraceDebug <string, string>(0L, "[WinRMRequestTracker::TryReviseAction] Start tracking command {0} - {1} in cache.", commandId, winRMInfo.CommandName);
WinRMRequestTracker.CommandIdToCommandNameCache.InsertSliding(commandId, winRMInfo.CommandName, WinRMRequestTracker.SlidingTimeSpan, null);
}
string str;
if (("Receive".Equals(action) || "Command:Receive".Equals(action)) && WinRMRequestTracker.CommandIdToCommandNameCache.TryGetValue(commandId, out str))
{
revisedAction = str + ":Receive";
ExTraceGlobals.HttpModuleTracer.TraceDebug <string, string>(0L, "[WinRMRequestTracker::TryReviseAction] Revise action from {0} to {1}.", action, revisedAction);
return(true);
}
return(false);
}
else
{
int num2;
if ("Receive".Equals(action) && status == 500 && WinRMRequestTracker.SessionIdToStateCache.TryGetValue(text, out num2) && num2 >= 10)
{
ExTraceGlobals.HttpModuleTracer.TraceDebug <int, int>(0L, "[WinRMRequestTracker::TryReviseAction] Ping detected. Status = {0}, curSessionState = {1}", status, num2);
revisedAction = "Ping";
if (num2 == 20)
{
ExTraceGlobals.HttpModuleTracer.TraceDebug <string>(0L, "[WinRMRequestTracker::TryReviseAction] Remove session state. sessionId = {1}", text);
WinRMRequestTracker.SessionIdToStateCache.Remove(text);
}
return(true);
}
int num3;
if ("Receive".Equals(action) && WinRMRequestTracker.SessionIdToStateCache.TryGetValue(text, out num3) && num3 < 10 && num3 < 3)
{
revisedAction = "New-PSSession:Receive";
num3++;
WinRMRequestTracker.SessionIdToStateCache.InsertSliding(text, num3, WinRMRequestTracker.SlidingTimeSpan, null);
ExTraceGlobals.HttpModuleTracer.TraceDebug <string, string, int>(0L, "[WinRMRequestTracker::TryReviseAction] Revise session from {0} to {1}. curSessionState = {2}", action, revisedAction, num3);
return(true);
}
return(false);
}
}
// Token: 0x060006EE RID: 1774 RVA: 0x00028810 File Offset: 0x00026A10
protected override void AddProtocolSpecificHeadersToServerRequest(WebHeaderCollection headers)
{
if (base.ClientRequest.IsAuthenticated && base.ProxyToDownLevel)
{
IIdentity callerIdentity = this.GetCallerIdentity();
WindowsIdentity windowsIdentity = callerIdentity as WindowsIdentity;
GenericSidIdentity genericSidIdentity = callerIdentity as GenericSidIdentity;
IPrincipal user = base.HttpContext.User;
if (windowsIdentity != null)
{
string text;
if (HttpContextItemParser.TryGetLiveIdMemberName(base.HttpContext.Items, ref text))
{
headers["X-RemotePS-GenericIdentity"] = windowsIdentity.User.ToString();
}
else
{
headers["X-RemotePS-WindowsIdentity"] = this.GetSerializedAccessTokenString();
}
}
else if (genericSidIdentity != null)
{
headers["X-RemotePS-GenericIdentity"] = genericSidIdentity.Sid.ToString();
}
else
{
headers["X-RemotePS-GenericIdentity"] = IIdentityExtensions.GetSafeName(base.HttpContext.User.Identity, true);
}
}
if (this.isSyndicatedAdminManageDownLevelTarget)
{
headers["msExchCafeForceRouteToLogonAccount"] = "1";
}
if (LoggerHelper.IsProbePingRequest(base.ClientRequest))
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(base.Logger, 21, "ProbePingBackend");
}
else if (WinRMHelper.WinRMParserEnabled.Value)
{
try
{
this.winRMInfo = base.ParseClientRequest <WinRMInfo>(new Func <Stream, WinRMInfo>(this.ParseWinRMInfo), 10000);
}
catch (InvalidOperationException ex)
{
if (ExTraceGlobals.ExceptionTracer.IsTraceEnabled(3))
{
ExTraceGlobals.ExceptionTracer.TraceError <InvalidOperationException>((long)this.GetHashCode(), "[RemotePowerShellProxyRequestHandler::AddProtocolSpecificHeadersToServerRequest] ParseClientRequest throws exception {0}", ex);
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericError(base.Logger, "ParseClientRequestException", ex.ToString());
}
if (this.winRMInfo != null)
{
WinRMInfo.StampToHttpHeaders(this.winRMInfo, headers);
}
}
DatabaseBasedAnchorMailbox databaseBasedAnchorMailbox = base.AnchoredRoutingTarget.AnchorMailbox as DatabaseBasedAnchorMailbox;
if (databaseBasedAnchorMailbox != null)
{
ADObjectId database = databaseBasedAnchorMailbox.GetDatabase();
if (database != null)
{
headers["X-DatabaseGuid"] = database.ObjectGuid.ToString();
}
}
if (!base.ShouldRetryOnError)
{
headers["X-Cafe-Last-Retry"] = "Y";
}
base.AddProtocolSpecificHeadersToServerRequest(headers);
}
private static void ApplicationBeginRequest(object sender, EventArgs e)
{
if (!FailFastUserCache.FailFastEnabled)
{
return;
}
Logger.EnterFunction(ExTraceGlobals.FailFastModuleTracer, "FailFastModule.ApplicationBeginRequest");
HttpApplication httpApplication = (HttpApplication)sender;
HttpContext context = httpApplication.Context;
string text = null;
foreach (IUserTokenParser userTokenParser in FailFastModule.tokenParsers)
{
if (userTokenParser.TryParseUserToken(context, out text))
{
Logger.TraceInformation(ExTraceGlobals.FailFastModuleTracer, "{0} module parses the user token successfully. User token parsed: {1}.", new object[]
{
userTokenParser.GetType(),
text
});
break;
}
}
if (string.IsNullOrEmpty(text))
{
Logger.TraceDebug(ExTraceGlobals.FailFastModuleTracer, "No usertoken is parsed, exit directly.", new object[0]);
Logger.ExitFunction(ExTraceGlobals.FailFastModuleTracer, "FailFastModule.ApplicationBeginRequest");
return;
}
if (context == null || context.Response == null)
{
Logger.TraceDebug(ExTraceGlobals.FailFastModuleTracer, "context == null || context.Response == null", new object[0]);
Logger.ExitFunction(ExTraceGlobals.FailFastModuleTracer, "FailFastModule.ApplicationBeginRequest");
return;
}
context.Response.Headers[FailFastModule.headerKeyToStoreUserToken] = text;
string userTenant = FailFastModule.GetUserTenant(context, text);
Logger.TraceDebug(ExTraceGlobals.FailFastModuleTracer, "Tenant for current user {0} is {1} (If not email domain, it is in Delegated scenario).", new object[]
{
text,
userTenant
});
string text2;
FailFastUserCacheValue failFastUserCacheValue;
BlockedReason blockedReason;
if (!FailFastUserCache.Instance.IsUserInCache(text, userTenant, out text2, out failFastUserCacheValue, out blockedReason))
{
Logger.TraceDebug(ExTraceGlobals.FailFastModuleTracer, "Http request of User {0} is not handled by FailFastModule because it is not in FailFastUserCache.", new object[]
{
text
});
Logger.ExitFunction(ExTraceGlobals.FailFastModuleTracer, "FailFastModule.ApplicationBeginRequest");
return;
}
if (!ConnectedUserManager.ShouldFailFastUserInCache(text, text2, failFastUserCacheValue, blockedReason))
{
Logger.TraceDebug(ExTraceGlobals.FailFastModuleTracer, "Http request of User {0} is not considered to be FailFast case. CacheKey: {1}. CacheValue: {2}. BlockedReason {3}.", new object[]
{
text,
text2,
failFastUserCacheValue,
blockedReason
});
Logger.ExitFunction(ExTraceGlobals.FailFastModuleTracer, "FailFastModule.ApplicationBeginRequest");
return;
}
Logger.LogEvent(TaskEventLogConstants.Tuple_LogUserRequestIsFailed, text2, new object[]
{
text,
text2,
failFastUserCacheValue.ToString()
});
Logger.TraceError(ExTraceGlobals.FailFastModuleTracer, "Http request of User {0} is terminated in fail-fast module.", new object[]
{
text
});
FailFastModule.perfCounter.RequestsBeFailFasted.RawValue = FailFastModule.perfCounter.RequestsBeFailFasted.RawValue + 1L;
HttpLogger.SafeSetLogger(RpsHttpMetadata.FailFast, string.Concat(new object[]
{
text,
"+",
blockedReason,
"+",
(failFastUserCacheValue == null) ? "Null" : failFastUserCacheValue.HitCount.ToString()
}));
ConnectedUserManager.RemoveUser(text);
string responseErrorMessage = FailFastModule.GetResponseErrorMessage(blockedReason);
context.Response.ContentType = "application/soap+xml;charset=UTF-8";
context.Response.Write(responseErrorMessage);
context.Response.StatusCode = 400;
context.Response.SubStatusCode = 350;
context.Response.TrySkipIisCustomErrors = true;
WinRMInfo.SetFailureCategoryInfo(context.Response.Headers, FailureCategory.FailFast, blockedReason.ToString());
Logger.TraceInformation(ExTraceGlobals.FailFastModuleTracer, "Sending 400.350 to the client.", new object[0]);
context.Response.End();
Logger.ExitFunction(ExTraceGlobals.FailFastModuleTracer, "FailFastModule.ApplicationBeginRequest");
}
