public RequestHelper(Func <WebRequest> createRequest, Action <WebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider, bool disableBuffering) { this._createRequest = createRequest; this._prepareRequest = prepareRequest; this._proxyCache = proxyCache; this._credentialCache = credentialCache; this._credentialProvider = credentialProvider; this._disableBuffering = disableBuffering; }
public ProxyServer(IProxyServerConfiguration proxyServerConfiguration, IProfileManager profileManager, IProxyCache proxyCache, CertificateGenerator certificateGenerator, ICertificateManager certificateManager) { _proxyServerConfiguration = proxyServerConfiguration; _profileManager = profileManager; _proxyCache = proxyCache; _certificateGenerator = certificateGenerator; _certificateManager = certificateManager; ServicePointManager.ServerCertificateValidationCallback = delegate { return true; }; }
public RequestHelper(Func <HttpWebRequest> createRequest, Action <HttpWebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider) { _createRequest = createRequest; _prepareRequest = prepareRequest; _proxyCache = proxyCache; _credentialCache = credentialCache; _credentialProvider = credentialProvider; }
public RequestHelper(Func<HttpWebRequest> createRequest, Action<HttpWebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider) { _createRequest = createRequest; _prepareRequest = prepareRequest; _proxyCache = proxyCache; _credentialCache = credentialCache; _credentialProvider = credentialProvider; }
public RequestHelper(Func<WebRequest> createRequest, Action<WebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider, bool disableBuffering) { _createRequest = createRequest; _prepareRequest = prepareRequest; _proxyCache = proxyCache; _credentialCache = credentialCache; _credentialProvider = credentialProvider; _disableBuffering = disableBuffering; }
public RequestHelper(Func <WebRequest> createRequest, Action <WebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider, bool disableBuffering, bool bypassProxy) { _createRequest = createRequest; _prepareRequest = prepareRequest; _proxyCache = proxyCache; _credentialCache = credentialCache; _credentialProvider = credentialProvider; _disableBuffering = disableBuffering; _bypassProxy = bypassProxy; }
/// <summary> /// Initializes the <see cref="ProxyFactory"/> instance /// with the <paramref name="source"/> container. /// </summary> /// <param name="source">The <see cref="IServiceContainer"/> instance that will hold the ProxyFactory.</param> public virtual void Initialize(IServiceContainer source) { if (source.Contains(typeof(IProxyBuilder), new Type[0])) { ProxyBuilder = (IProxyBuilder)source.GetService(typeof(IProxyBuilder)); } if (source.Contains(typeof(IExtractInterfaces), new Type[0])) { InterfaceExtractor = (IExtractInterfaces)source.GetService(typeof(IExtractInterfaces)); } //if (source.Contains(typeof(IVerifier))) // Verifier = source.GetService<IVerifier>(); if (source.Contains(typeof(IProxyCache), new Type[0])) { Cache = (IProxyCache)source.GetService(typeof(IProxyCache)); } }
internal static WebResponse GetResponse(Func <WebRequest> createRequest, Action <WebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider) { HttpWebRequest previousRequest = null; IHttpWebResponse previousResponse = null; HttpStatusCode? previousStatusCode = null; bool usingSTSAuth = false; bool continueIfFailed = true; int proxyCredentialsRetryCount = 0; int credentialsRetryCount = 0; while (true) { // Create the request var request = (HttpWebRequest)createRequest(); request.Proxy = proxyCache.GetProxy(request.RequestUri); if (request.Proxy != null && request.Proxy.Credentials == null) { request.Proxy.Credentials = CredentialCache.DefaultCredentials; } if (previousResponse == null || ShouldKeepAliveBeUsedInRequest(previousRequest, previousResponse)) { // Try to use the cached credentials (if any, for the first request) request.Credentials = credentialCache.GetCredentials(request.RequestUri); // If there are no cached credentials, use the default ones if (request.Credentials == null) { request.UseDefaultCredentials = true; } } else if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired) { request.Proxy.Credentials = credentialProvider.GetCredentials(request, CredentialType.ProxyCredentials, retrying: proxyCredentialsRetryCount > 0); continueIfFailed = request.Proxy.Credentials != null; proxyCredentialsRetryCount++; } else if ((previousStatusCode == HttpStatusCode.Unauthorized) && !usingSTSAuth) { // If we are using STS, the auth's being performed by a request header. We do not need to ask the user for credentials at this point. request.Credentials = credentialProvider.GetCredentials(request, CredentialType.RequestCredentials, retrying: credentialsRetryCount > 0); continueIfFailed = request.Credentials != null; credentialsRetryCount++; } try { ICredentials credentials = request.Credentials; SetKeepAliveHeaders(request, previousResponse); if (usingSTSAuth) { // Add request headers if the server requires STS based auth. STSAuthHelper.PrepareSTSRequest(request); } // Prepare the request, we do something like write to the request stream // which needs to happen last before the request goes out prepareRequest(request); // Wrap the credentials in a CredentialCache in case there is a redirect // and credentials need to be kept around. request.Credentials = request.Credentials.AsCredentialCache(request.RequestUri); WebResponse response = request.GetResponse(); // Cache the proxy and credentials proxyCache.Add(request.Proxy); credentialCache.Add(request.RequestUri, credentials); credentialCache.Add(response.ResponseUri, credentials); return(response); } catch (WebException ex) { using (IHttpWebResponse response = GetResponse(ex.Response)) { if (response == null && ex.Status != WebExceptionStatus.SecureChannelFailure) { // No response, something went wrong so just rethrow throw; } // Special case https connections that might require authentication if (ex.Status == WebExceptionStatus.SecureChannelFailure) { if (continueIfFailed) { // Act like we got a 401 so that we prompt for credentials on the next request previousStatusCode = HttpStatusCode.Unauthorized; continue; } throw; } // If we were trying to authenticate the proxy or the request and succeeded, cache the result. if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired && response.StatusCode != HttpStatusCode.ProxyAuthenticationRequired) { proxyCache.Add(request.Proxy); } else if (previousStatusCode == HttpStatusCode.Unauthorized && response.StatusCode != HttpStatusCode.Unauthorized) { credentialCache.Add(request.RequestUri, request.Credentials); credentialCache.Add(response.ResponseUri, request.Credentials); } usingSTSAuth = STSAuthHelper.TryRetrieveSTSToken(request.RequestUri, response); if (!IsAuthenticationResponse(response) || !continueIfFailed) { throw; } previousRequest = request; previousResponse = response; previousStatusCode = previousResponse.StatusCode; } } } }
/// <summary> /// Keeps sending requests until a response code that doesn't require authentication happens or if /// the request requires authentication and the user has stopped trying to enter them (i.e. they hit cancel when they are prompted). /// </summary> internal static WebResponse GetResponse(Func<WebRequest> createRequest, Action<WebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider) { IHttpWebResponse previousResponse = null; HttpStatusCode? previousStatusCode = null; bool usingSTSAuth = false; bool continueIfFailed = true; int proxyCredentialsRetryCount = 0; int credentialsRetryCount = 0; while (true) { // Create the request var request = (HttpWebRequest)createRequest(); request.Proxy = proxyCache.GetProxy(request.RequestUri); if (request.Proxy != null && request.Proxy.Credentials == null) { request.Proxy.Credentials = CredentialCache.DefaultCredentials; } if (previousResponse == null) { // Try to use the cached credentials (if any, for the first request) request.Credentials = credentialCache.GetCredentials(request.RequestUri); // If there are no cached credentials, use the default ones if (request.Credentials == null) { request.UseDefaultCredentials = true; } } else if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired) { request.Proxy.Credentials = credentialProvider.GetCredentials(request, CredentialType.ProxyCredentials, retrying: proxyCredentialsRetryCount > 0); continueIfFailed = request.Proxy.Credentials != null; proxyCredentialsRetryCount++; } else if ((previousStatusCode == HttpStatusCode.Unauthorized) && !usingSTSAuth) { // If we are using STS, the auth's being performed by a request header. We do not need to ask the user for credentials at this point. request.Credentials = credentialProvider.GetCredentials(request, CredentialType.RequestCredentials, retrying: credentialsRetryCount > 0); continueIfFailed = request.Credentials != null; credentialsRetryCount++; } try { ICredentials credentials = request.Credentials; SetKeepAliveHeaders(request, previousResponse); if (usingSTSAuth) { // Add request headers if the server requires STS based auth. STSAuthHelper.PrepareSTSRequest(request); } // Prepare the request, we do something like write to the request stream // which needs to happen last before the request goes out prepareRequest(request); // Wrap the credentials in a CredentialCache in case there is a redirect // and credentials need to be kept around. request.Credentials = request.Credentials.AsCredentialCache(request.RequestUri); WebResponse response = request.GetResponse(); // Cache the proxy and credentials proxyCache.Add(request.Proxy); credentialCache.Add(request.RequestUri, credentials); credentialCache.Add(response.ResponseUri, credentials); return response; } catch (WebException ex) { using (IHttpWebResponse response = GetResponse(ex.Response)) { if (response == null && ex.Status != WebExceptionStatus.SecureChannelFailure) { // No response, something went wrong so just rethrow throw; } // Special case https connections that might require authentication if (ex.Status == WebExceptionStatus.SecureChannelFailure) { if (continueIfFailed) { // Act like we got a 401 so that we prompt for credentials on the next request previousStatusCode = HttpStatusCode.Unauthorized; continue; } throw; } // If we were trying to authenticate the proxy or the request and succeeded, cache the result. if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired && response.StatusCode != HttpStatusCode.ProxyAuthenticationRequired) { proxyCache.Add(request.Proxy); } else if (previousStatusCode == HttpStatusCode.Unauthorized && response.StatusCode != HttpStatusCode.Unauthorized) { credentialCache.Add(request.RequestUri, request.Credentials); credentialCache.Add(response.ResponseUri, request.Credentials); } usingSTSAuth = STSAuthHelper.TryRetrieveSTSToken(request.RequestUri, response); if (!IsAuthenticationResponse(response) || !continueIfFailed) { throw; } previousResponse = response; previousStatusCode = previousResponse.StatusCode; } } } }
/// <summary> /// Keeps sending requests until a response code that doesn't require authentication happens or if /// the request requires authentication and the user has stopped trying to enter them (i.e. they hit cancel when they are prompted). /// </summary> internal static WebResponse GetResponse(Func<WebRequest> createRequest, Action<WebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider) { HttpStatusCode? previousStatusCode = null; string authType = null; bool continueIfFailed = true; while (true) { // Create the request WebRequest request = createRequest(); request.Proxy = proxyCache.GetProxy(request.RequestUri); if (request.Proxy != null && request.Proxy.Credentials == null) { request.Proxy.Credentials = CredentialCache.DefaultCredentials; } if (previousStatusCode == null) { // Try to use the cached credentials (if any, for the first request) request.Credentials = credentialCache.GetCredentials(request.RequestUri); if (request.Credentials == null) { // If there are no cached credentials, use the default ones request.UseDefaultCredentials = true; } } else if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired) { request.Proxy.Credentials = credentialProvider.GetCredentials(request, CredentialType.ProxyCredentials); continueIfFailed = request.Proxy.Credentials != null; } else if (previousStatusCode == HttpStatusCode.Unauthorized) { request.Credentials = credentialProvider.GetCredentials(request, CredentialType.RequestCredentials); continueIfFailed = request.Credentials != null; } try { ICredentials credentials = request.Credentials; // KeepAlive is required for NTLM and Kerberos authentication. // REVIEW: The WWW-Authenticate header is tricky to parse so a Equals might not be correct if (!String.Equals(authType, "NTLM", StringComparison.OrdinalIgnoreCase) && !String.Equals(authType, "Kerberos", StringComparison.OrdinalIgnoreCase)) { // This is to work around the "The underlying connection was closed: An unexpected error occurred on a receive." // exception. var httpRequest = (HttpWebRequest)request; httpRequest.KeepAlive = false; httpRequest.ProtocolVersion = HttpVersion.Version10; } // Prepare the request, we do something like write to the request stream // which needs to happen last before the request goes out prepareRequest(request); // Wrap the credentials in a CredentialCache in case there is a redirect // and credentials need to be kept around. request.Credentials = request.Credentials.AsCredentialCache(request.RequestUri); WebResponse response = request.GetResponse(); // Cache the proxy and credentials proxyCache.Add(request.Proxy); credentialCache.Add(request.RequestUri, credentials); credentialCache.Add(response.ResponseUri, credentials); return response; } catch (WebException ex) { IHttpWebResponse response = GetResponse(ex.Response); if (response == null && ex.Status != WebExceptionStatus.SecureChannelFailure) { // No response, something went wrong so just rethrow throw; } // Special case https connections that might require authentication if (ex.Status == WebExceptionStatus.SecureChannelFailure) { if (continueIfFailed) { // Act like we got a 401 so that we prompt for credentials on the next request previousStatusCode = HttpStatusCode.Unauthorized; continue; } throw; } // If we were trying to authenticate the proxy or the request and succeeded, cache the result. if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired && response.StatusCode != HttpStatusCode.ProxyAuthenticationRequired) { proxyCache.Add(request.Proxy); } else if (previousStatusCode == HttpStatusCode.Unauthorized && response.StatusCode != HttpStatusCode.Unauthorized) { credentialCache.Add(request.RequestUri, request.Credentials); credentialCache.Add(response.ResponseUri, request.Credentials); } if (!IsAuthenticationResponse(response) || !continueIfFailed) { throw; } using (response) { previousStatusCode = response.StatusCode; authType = response.AuthType; } } } }