public void ProxyExplicitlyProvided_DefaultCredentials_Ignored()
{
int port;
Task <LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(out port, requireAuth: true, expectCreds: true);
Uri proxyUrl = new Uri($"http://localhost:{port}");
var rightCreds = new NetworkCredential("rightusername", "rightpassword");
var wrongCreds = new NetworkCredential("wrongusername", "wrongpassword");
using (var handler = new HttpClientHandler())
using (var client = new HttpClient(handler))
{
handler.Proxy = new UseSpecifiedUriWebProxy(proxyUrl, rightCreds);
handler.DefaultProxyCredentials = wrongCreds;
Task <HttpResponseMessage> responseTask = client.GetAsync(Configuration.Http.RemoteEchoServer);
Task <string> responseStringTask = responseTask.ContinueWith(t => t.Result.Content.ReadAsStringAsync(), TaskScheduler.Default).Unwrap();
Task.WaitAll(proxyTask, responseTask, responseStringTask);
TestHelper.VerifyResponseBody(responseStringTask.Result, responseTask.Result.Content.Headers.ContentMD5, false, null);
Assert.Equal(Encoding.ASCII.GetString(proxyTask.Result.ResponseContent), responseStringTask.Result);
string expectedAuth = $"{rightCreds.UserName}:{rightCreds.Password}";
Assert.Equal(expectedAuth, proxyTask.Result.AuthenticationHeaderValue);
}
}
[PlatformSpecific(TestPlatforms.AnyUnix)] // proxies set via the http_proxy environment variable are specific to Unix
public void ProxySetViaEnvironmentVariable_DefaultProxyCredentialsUsed()
{
int port;
Task <LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(out port, requireAuth: true, expectCreds: true);
const string ExpectedUsername = "******";
const string ExpectedPassword = "******";
// libcurl will read a default proxy from the http_proxy environment variable. Ensure that when it does,
// our default proxy credentials are used. To avoid messing up anything else in this process, we run the
// test in another process.
var psi = new ProcessStartInfo();
psi.Environment.Add("http_proxy", $"http://localhost:{port}");
RemoteInvoke(() =>
{
using (var handler = new HttpClientHandler())
using (var client = new HttpClient(handler))
{
var creds = new NetworkCredential(ExpectedUsername, ExpectedPassword);
handler.DefaultProxyCredentials = creds;
Task <HttpResponseMessage> responseTask = client.GetAsync(Configuration.Http.RemoteEchoServer);
Task <string> responseStringTask = responseTask.ContinueWith(t => t.Result.Content.ReadAsStringAsync(), TaskScheduler.Default).Unwrap();
Task.WaitAll(responseTask, responseStringTask);
TestHelper.VerifyResponseBody(responseStringTask.Result, responseTask.Result.Content.Headers.ContentMD5, false, null);
}
return(SuccessExitCode);
}, new RemoteInvokeOptions {
StartInfo = psi
}).Dispose();
Assert.Equal($"{ExpectedUsername}:{ExpectedPassword}", proxyTask.Result.AuthenticationHeaderValue);
}
public void UseCallback_HaveNoCredsAndUseAuthenticatedCustomProxyAndPostToSecureServer_ProxyAuthenticationRequiredStatusCode()
{
int port;
Task <LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(
out port,
requireAuth: true,
expectCreds: false);
Uri proxyUrl = new Uri($"http://localhost:{port}");
var handler = new HttpClientHandler();
handler.Proxy = new UseSpecifiedUriWebProxy(proxyUrl, null);
handler.ServerCertificateCustomValidationCallback = delegate { return(true); };
using (var client = new HttpClient(handler))
{
Task <HttpResponseMessage> responseTask = client.PostAsync(
Configuration.Http.SecureRemoteEchoServer,
new StringContent("This is a test"));
Task.WaitAll(proxyTask, responseTask);
using (responseTask.Result)
{
Assert.Equal(HttpStatusCode.ProxyAuthenticationRequired, responseTask.Result.StatusCode);
}
}
}
public async Task UseCallback_HaveNoCredsAndUseAuthenticatedCustomProxyAndPostToSecureServer_ProxyAuthenticationRequiredStatusCode()
{
if (ManagedHandlerTestHelpers.IsEnabled)
{
return; // TODO #23136: SSL proxy tunneling not yet implemented in ManagedHandler
}
int port;
Task <LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(
out port,
requireAuth: true,
expectCreds: false);
Uri proxyUrl = new Uri($"http://localhost:{port}");
var handler = new HttpClientHandler();
handler.Proxy = new UseSpecifiedUriWebProxy(proxyUrl, null);
handler.ServerCertificateCustomValidationCallback = delegate { return(true); };
using (var client = new HttpClient(handler))
{
Task <HttpResponseMessage> responseTask = client.PostAsync(
Configuration.Http.SecureRemoteEchoServer,
new StringContent("This is a test"));
await TestHelper.WhenAllCompletedOrAnyFailed(proxyTask, responseTask);
using (responseTask.Result)
{
Assert.Equal(HttpStatusCode.ProxyAuthenticationRequired, responseTask.Result.StatusCode);
}
}
}
public void Proxy_BypassFalse_GetRequestGoesThroughCustomProxy(ICredentials creds)
{
int port;
Task <LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(
out port,
requireAuth: creds != null && creds != CredentialCache.DefaultCredentials,
expectCreds: true);
Uri proxyUrl = new Uri($"http://localhost:{port}");
using (var handler = new HttpClientHandler()
{
Proxy = new UseSpecifiedUriWebProxy(proxyUrl, creds)
})
using (var client = new HttpClient(handler))
{
Task <HttpResponseMessage> responseTask = client.GetAsync(HttpTestServers.RemoteEchoServer);
Task <string> responseStringTask = responseTask.ContinueWith(t => t.Result.Content.ReadAsStringAsync(), TaskScheduler.Default).Unwrap();
Task.WaitAll(proxyTask, responseTask, responseStringTask);
TestHelper.VerifyResponseBody(responseStringTask.Result, responseTask.Result.Content.Headers.ContentMD5, false, null);
Assert.Equal(Encoding.ASCII.GetString(proxyTask.Result.ResponseContent), responseStringTask.Result);
NetworkCredential nc = creds != null?creds.GetCredential(proxyUrl, "Basic") : null;
string expectedAuth =
nc == null || nc == CredentialCache.DefaultCredentials ? null :
string.IsNullOrEmpty(nc.Domain) ? $"{nc.UserName}:{nc.Password}" :
$"{nc.Domain}\\{nc.UserName}:{nc.Password}";
Assert.Equal(expectedAuth, proxyTask.Result.AuthenticationHeaderValue);
}
}
public async Task UseCallback_HaveCredsAndUseAuthenticatedCustomProxyAndPostToSecureServer_Success()
{
if (!BackendSupportsCustomCertificateHandling)
{
return;
}
if (IsWinHttpHandler && PlatformDetection.IsWindows7)
{
// Issue #27612
return;
}
const string content = "This is a test";
int port;
Task <LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(
out port,
requireAuth: true,
expectCreds: true);
Uri proxyUrl = new Uri($"http://localhost:{port}");
HttpClientHandler handler = CreateHttpClientHandler();
handler.Proxy = new UseSpecifiedUriWebProxy(proxyUrl, new NetworkCredential("rightusername", "rightpassword"));
handler.ServerCertificateCustomValidationCallback = delegate { return(true); };
using (var client = new HttpClient(handler))
{
HttpResponseMessage response = await client.PostAsync(
Configuration.Http.SecureRemoteEchoServer,
new StringContent(content));
string responseContent = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
TestHelper.VerifyResponseBody(
responseContent,
response.Content.Headers.ContentMD5,
false,
content);
}
// Don't await proxyTask until the HttpClient is closed, otherwise it will wait for connection timeout.
await proxyTask;
}
public void Proxy_HaveNoCredsAndUseAuthenticatedCustomProxy_ProxyAuthenticationRequiredStatusCode()
{
int port;
Task <LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(
out port,
requireAuth: true,
expectCreds: false);
Uri proxyUrl = new Uri($"http://localhost:{port}");
using (var handler = new HttpClientHandler()
{
Proxy = new UseSpecifiedUriWebProxy(proxyUrl, null)
})
using (var client = new HttpClient(handler))
{
Task <HttpResponseMessage> responseTask = client.GetAsync(HttpTestServers.RemoteEchoServer);
Task.WaitAll(proxyTask, responseTask);
Assert.Equal(HttpStatusCode.ProxyAuthenticationRequired, responseTask.Result.StatusCode);
}
}