Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -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()) {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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()) {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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,
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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");
Expand Down Expand Up @@ -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");
Expand Down
Original file line number Diff line number Diff line change
@@ -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
* <http://www.apache.org/>.
*
*/
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);
}

}
Loading
Loading