diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/AsyncCachingExec.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/AsyncCachingExec.java
index d3f8346ddd..4eda6d6c7f 100644
--- a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/AsyncCachingExec.java
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/AsyncCachingExec.java
@@ -752,7 +752,8 @@ public void cancelled() {
final ResponseCacheControl responseCacheControl = CacheControlHeaderParser.INSTANCE.parse(backendResponse);
context.setResponseCacheControl(responseCacheControl);
final boolean cacheable = responseCachingPolicy.isResponseCacheable(
- requestCacheControl, responseCacheControl, request, backendResponse);
+ requestCacheControl, responseCacheControl, request, backendResponse,
+ isTargetAuthenticated(context, scope.route));
if (cacheable) {
storeRequestIfModifiedSinceFor304Response(request, backendResponse);
if (LOG.isDebugEnabled()) {
diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CachingExec.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CachingExec.java
index 116e994240..9fbc71bcd6 100644
--- a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CachingExec.java
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CachingExec.java
@@ -552,7 +552,8 @@ ClassicHttpResponse handleBackendResponse(
final ResponseCacheControl responseCacheControl = CacheControlHeaderParser.INSTANCE.parse(backendResponse);
context.setResponseCacheControl(responseCacheControl);
final boolean cacheable = responseCachingPolicy.isResponseCacheable(
- requestCacheControl, responseCacheControl, request, backendResponse);
+ requestCacheControl, responseCacheControl, request, backendResponse,
+ isTargetAuthenticated(context, scope.route));
if (cacheable) {
storeRequestIfModifiedSinceFor304Response(request, backendResponse);
if (LOG.isDebugEnabled()) {
diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CachingExecBase.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CachingExecBase.java
index 3e2db95f0c..8dec485f4e 100644
--- a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CachingExecBase.java
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CachingExecBase.java
@@ -29,10 +29,13 @@
import java.time.Instant;
import java.util.concurrent.atomic.AtomicLong;
+import org.apache.hc.client5.http.HttpRoute;
import org.apache.hc.client5.http.async.methods.SimpleHttpResponse;
+import org.apache.hc.client5.http.auth.AuthExchange;
import org.apache.hc.client5.http.cache.HttpCacheContext;
import org.apache.hc.client5.http.cache.HttpCacheEntry;
import org.apache.hc.client5.http.cache.ResourceIOException;
+import org.apache.hc.client5.http.protocol.HttpClientContext;
import org.apache.hc.core5.http.EntityDetails;
import org.apache.hc.core5.http.Header;
import org.apache.hc.core5.http.HttpHeaders;
@@ -118,6 +121,23 @@ public long getCacheUpdates() {
return cacheUpdates.get();
}
+ /**
+ * Determines whether the protocol layer below the cache authenticated the request
+ * to the route target. The {@code Authorization} header generated from the
+ * credentials provider or the auth cache is added to the request instance
+ * executed by the protocol layer and is not visible to the cache, so check the
+ * request last sent to the backend. A connection-based scheme does not resend
+ * the header once the exchange has succeeded, so check the exchange state as well.
+ */
+ static boolean isTargetAuthenticated(final HttpClientContext context, final HttpRoute route) {
+ final HttpRequest sentRequest = context.getRequest();
+ if (sentRequest != null && sentRequest.containsHeader(HttpHeaders.AUTHORIZATION)) {
+ return true;
+ }
+ final AuthExchange authExchange = context.getAuthExchanges().get(route.getTargetHost());
+ return authExchange != null && authExchange.getState() == AuthExchange.State.SUCCESS;
+ }
+
SimpleHttpResponse generateCachedResponse(
final HttpRequest request,
final HttpCacheEntry entry,
diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/ResponseCachingPolicy.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/ResponseCachingPolicy.java
index 9b829bbae2..3591effe22 100644
--- a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/ResponseCachingPolicy.java
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/ResponseCachingPolicy.java
@@ -91,6 +91,19 @@ public ResponseCachingPolicy(
* @return {@code true} if response is cacheable
*/
public boolean isResponseCacheable(final RequestCacheControl requestCacheControl, final ResponseCacheControl cacheControl, final HttpRequest request, final HttpResponse response) {
+ return isResponseCacheable(requestCacheControl, cacheControl, request, response, false);
+ }
+
+ /**
+ * Determine if the {@link HttpResponse} gotten from the origin is a
+ * cacheable response.
+ *
+ * @param requestCacheControl the cache control directives of the request
+ * @param authenticated {@code true} if the request was authenticated by the protocol
+ * layer with credentials not present in the given request
+ * @return {@code true} if response is cacheable
+ */
+ boolean isResponseCacheable(final RequestCacheControl requestCacheControl, final ResponseCacheControl cacheControl, final HttpRequest request, final HttpResponse response, final boolean authenticated) {
if (requestCacheControl.isNoStore()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Response is not cacheable as the request enforced no-store");
@@ -149,7 +162,7 @@ public boolean isResponseCacheable(final RequestCacheControl requestCacheControl
}
if (sharedCache) {
- if (request.containsHeader(HttpHeaders.AUTHORIZATION) &&
+ if ((authenticated || request.containsHeader(HttpHeaders.AUTHORIZATION)) &&
cacheControl.getSharedMaxAge() == -1 &&
!(cacheControl.isPublic() || cacheControl.isMustRevalidate())) {
LOG.debug("Request contains private credentials");
diff --git a/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/caching/async/TestCachingAsyncClientAuthentication.java b/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/caching/async/TestCachingAsyncClientAuthentication.java
new file mode 100644
index 0000000000..7bbc41689f
--- /dev/null
+++ b/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/caching/async/TestCachingAsyncClientAuthentication.java
@@ -0,0 +1,169 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ * .
+ *
+ */
+package org.apache.hc.client5.testing.caching.async;
+
+import java.net.InetSocketAddress;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.hc.client5.http.async.methods.SimpleHttpRequest;
+import org.apache.hc.client5.http.async.methods.SimpleHttpResponse;
+import org.apache.hc.client5.http.async.methods.SimpleRequestBuilder;
+import org.apache.hc.client5.http.auth.AuthCache;
+import org.apache.hc.client5.http.auth.UsernamePasswordCredentials;
+import org.apache.hc.client5.http.cache.HttpCacheContext;
+import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
+import org.apache.hc.client5.http.impl.auth.BasicAuthCache;
+import org.apache.hc.client5.http.impl.auth.BasicScheme;
+import org.apache.hc.client5.http.impl.auth.CredentialsProviderBuilder;
+import org.apache.hc.client5.http.impl.cache.HeapResourceFactory;
+import org.apache.hc.client5.testing.BasicTestAuthenticator;
+import org.apache.hc.client5.testing.async.AbstractSimpleServerExchangeHandler;
+import org.apache.hc.client5.testing.async.AuthenticatingAsyncDecorator;
+import org.apache.hc.client5.testing.extension.async.CachingHttpAsyncClientResource;
+import org.apache.hc.client5.testing.extension.async.ServerProtocolLevel;
+import org.apache.hc.client5.testing.extension.async.TestAsyncServerResources;
+import org.apache.hc.core5.http.ContentType;
+import org.apache.hc.core5.http.HttpHeaders;
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http.HttpStatus;
+import org.apache.hc.core5.http.URIScheme;
+import org.apache.hc.core5.http.protocol.HttpCoreContext;
+import org.apache.hc.core5.http2.HttpVersionPolicy;
+import org.apache.hc.core5.util.Timeout;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+/**
+ * A shared cache must not serve a response to an authenticated request
+ * to a different execution context.
+ */
+class TestCachingAsyncClientAuthentication {
+
+ static final Timeout TIMEOUT = Timeout.ofMinutes(1);
+
+ @RegisterExtension
+ private final TestAsyncServerResources serverResources;
+ @RegisterExtension
+ private final CachingHttpAsyncClientResource clientResource;
+
+ private final AtomicInteger originHits = new AtomicInteger();
+
+ TestCachingAsyncClientAuthentication() throws Exception {
+ this.serverResources = new TestAsyncServerResources(URIScheme.HTTP, TIMEOUT, ServerProtocolLevel.STANDARD);
+ this.serverResources.configureServer(bootstrap -> bootstrap
+ .setExchangeHandlerDecorator(exchangeHandler -> new AuthenticatingAsyncDecorator(
+ exchangeHandler, new BasicTestAuthenticator("test:test", "test realm")))
+ .register("*", () -> new AbstractSimpleServerExchangeHandler() {
+
+ @Override
+ protected SimpleHttpResponse handle(
+ final SimpleHttpRequest request,
+ final HttpCoreContext context) {
+ originHits.incrementAndGet();
+ final SimpleHttpResponse response = new SimpleHttpResponse(HttpStatus.SC_OK);
+ response.setHeader(HttpHeaders.CACHE_CONTROL, "max-age=60");
+ response.setBody("private data", ContentType.TEXT_PLAIN);
+ return response;
+ }
+
+ }));
+ this.clientResource = new CachingHttpAsyncClientResource(HttpVersionPolicy.FORCE_HTTP_1);
+ this.clientResource.configure(builder -> builder
+ .setResourceFactory(HeapResourceFactory.INSTANCE));
+ }
+
+ /**
+ * The test server doubles as a plain HTTP proxy, so requests are sent in absolute form
+ * and the protocol layer authenticates a copy of the request passed down by the cache.
+ */
+ HttpHost startServerAsProxy() throws Exception {
+ final InetSocketAddress address = serverResources.server().start();
+ clientResource.configure(builder -> builder
+ .setProxy(new HttpHost(serverResources.scheme().id, "127.0.0.1", address.getPort())));
+ return new HttpHost(serverResources.scheme().id, "localhost", address.getPort());
+ }
+
+ SimpleHttpResponse execute(
+ final CloseableHttpAsyncClient client,
+ final HttpHost target,
+ final HttpCacheContext context) throws Exception {
+ return client.execute(SimpleRequestBuilder.get()
+ .setHttpHost(target)
+ .setPath("/private")
+ .build(), context, null)
+ .get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
+ }
+
+ void assertAuthenticatedResponse(
+ final CloseableHttpAsyncClient client,
+ final HttpHost target,
+ final HttpCacheContext context) throws Exception {
+ final SimpleHttpResponse response = execute(client, target, context);
+ Assertions.assertEquals(HttpStatus.SC_OK, response.getCode());
+ Assertions.assertEquals("private data", response.getBodyText());
+ }
+
+ void assertNotServedToAnonymousContext(
+ final CloseableHttpAsyncClient client,
+ final HttpHost target) throws Exception {
+ final SimpleHttpResponse response = execute(client, target, HttpCacheContext.create());
+ Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response.getCode());
+ Assertions.assertEquals(1, originHits.get());
+ }
+
+ @Test
+ void testResponseToChallengedRequestNotServedToAnotherContext() throws Exception {
+ final HttpHost target = startServerAsProxy();
+ final CloseableHttpAsyncClient client = clientResource.client();
+
+ final HttpCacheContext context = HttpCacheContext.create();
+ context.setCredentialsProvider(CredentialsProviderBuilder.create()
+ .add(target, "test", "test".toCharArray())
+ .build());
+ assertAuthenticatedResponse(client, target, context);
+
+ assertNotServedToAnonymousContext(client, target);
+ }
+
+ @Test
+ void testResponseToPreemptiveRequestNotServedToAnotherContext() throws Exception {
+ final HttpHost target = startServerAsProxy();
+ final CloseableHttpAsyncClient client = clientResource.client();
+
+ final BasicScheme basicScheme = new BasicScheme();
+ basicScheme.initPreemptive(new UsernamePasswordCredentials("test", "test".toCharArray()));
+ final AuthCache authCache = new BasicAuthCache();
+ authCache.put(target, basicScheme);
+ final HttpCacheContext context = HttpCacheContext.create();
+ context.setAuthCache(authCache);
+ assertAuthenticatedResponse(client, target, context);
+
+ assertNotServedToAnonymousContext(client, target);
+ }
+
+}
diff --git a/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/caching/sync/TestCachingClientAuthentication.java b/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/caching/sync/TestCachingClientAuthentication.java
new file mode 100644
index 0000000000..b62cd97d21
--- /dev/null
+++ b/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/caching/sync/TestCachingClientAuthentication.java
@@ -0,0 +1,145 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ * .
+ *
+ */
+package org.apache.hc.client5.testing.caching.sync;
+
+import java.net.InetSocketAddress;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.hc.client5.http.auth.AuthCache;
+import org.apache.hc.client5.http.auth.UsernamePasswordCredentials;
+import org.apache.hc.client5.http.cache.HttpCacheContext;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.impl.auth.BasicAuthCache;
+import org.apache.hc.client5.http.impl.auth.BasicScheme;
+import org.apache.hc.client5.http.impl.auth.CredentialsProviderBuilder;
+import org.apache.hc.client5.http.impl.cache.HeapResourceFactory;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+import org.apache.hc.client5.testing.BasicTestAuthenticator;
+import org.apache.hc.client5.testing.classic.AuthenticatingDecorator;
+import org.apache.hc.client5.testing.extension.sync.CachingHttpClientResource;
+import org.apache.hc.client5.testing.extension.sync.TestServerResources;
+import org.apache.hc.core5.http.ContentType;
+import org.apache.hc.core5.http.HttpHeaders;
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http.HttpStatus;
+import org.apache.hc.core5.http.URIScheme;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
+import org.apache.hc.core5.http.io.entity.StringEntity;
+import org.apache.hc.core5.util.Timeout;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+/**
+ * A shared cache must not serve a response to an authenticated request
+ * to a different execution context.
+ */
+class TestCachingClientAuthentication {
+
+ static final Timeout TIMEOUT = Timeout.ofMinutes(1);
+
+ @RegisterExtension
+ private final TestServerResources serverResources;
+ @RegisterExtension
+ private final CachingHttpClientResource clientResource;
+
+ private final AtomicInteger originHits = new AtomicInteger();
+
+ TestCachingClientAuthentication() throws Exception {
+ this.serverResources = new TestServerResources(URIScheme.HTTP, TIMEOUT);
+ this.serverResources.configureServer(bootstrap -> bootstrap
+ .setExchangeHandlerDecorator(requestHandler -> new AuthenticatingDecorator(
+ requestHandler, new BasicTestAuthenticator("test:test", "test realm")))
+ .register("*", (request, response, context) -> {
+ originHits.incrementAndGet();
+ response.setCode(HttpStatus.SC_OK);
+ response.setHeader(HttpHeaders.CACHE_CONTROL, "max-age=60");
+ response.setEntity(new StringEntity("private data", ContentType.TEXT_PLAIN));
+ }));
+ this.clientResource = new CachingHttpClientResource();
+ this.clientResource.configure(builder -> builder
+ .setResourceFactory(HeapResourceFactory.INSTANCE));
+ }
+
+ HttpHost startServer() throws Exception {
+ final InetSocketAddress address = serverResources.server().start();
+ return new HttpHost(serverResources.scheme().id, "localhost", address.getPort());
+ }
+
+ void assertAuthenticatedResponse(
+ final CloseableHttpClient client,
+ final HttpHost target,
+ final HttpCacheContext context) throws Exception {
+ client.execute(target, new HttpGet("/private"), context, response -> {
+ Assertions.assertEquals(HttpStatus.SC_OK, response.getCode());
+ Assertions.assertEquals("private data", EntityUtils.toString(response.getEntity()));
+ return null;
+ });
+ }
+
+ void assertNotServedToAnonymousContext(
+ final CloseableHttpClient client,
+ final HttpHost target) throws Exception {
+ client.execute(target, new HttpGet("/private"), HttpCacheContext.create(), response -> {
+ Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response.getCode());
+ EntityUtils.consume(response.getEntity());
+ return null;
+ });
+ Assertions.assertEquals(1, originHits.get());
+ }
+
+ @Test
+ void testResponseToChallengedRequestNotServedToAnotherContext() throws Exception {
+ final HttpHost target = startServer();
+ final CloseableHttpClient client = clientResource.client();
+
+ final HttpCacheContext context = HttpCacheContext.create();
+ context.setCredentialsProvider(CredentialsProviderBuilder.create()
+ .add(target, "test", "test".toCharArray())
+ .build());
+ assertAuthenticatedResponse(client, target, context);
+
+ assertNotServedToAnonymousContext(client, target);
+ }
+
+ @Test
+ void testResponseToPreemptiveRequestNotServedToAnotherContext() throws Exception {
+ final HttpHost target = startServer();
+ final CloseableHttpClient client = clientResource.client();
+
+ final BasicScheme basicScheme = new BasicScheme();
+ basicScheme.initPreemptive(new UsernamePasswordCredentials("test", "test".toCharArray()));
+ final AuthCache authCache = new BasicAuthCache();
+ authCache.put(target, basicScheme);
+ final HttpCacheContext context = HttpCacheContext.create();
+ context.setAuthCache(authCache);
+ assertAuthenticatedResponse(client, target, context);
+
+ assertNotServedToAnonymousContext(client, target);
+ }
+
+}