Use private caching on secure connections If a user asks for a resource over a secure connection, only permit the browser to cache the resource. This prevents a man in the middle proxy from accidentially caching a Set-Cookie header. Define caching rules in a CacheHeaders helper class that can be used within Gerrit Code Review, enabling Gerrit to match behavior. Change-Id: Ibb9c3b6ccf0e16430f1adae96e8e2680f77925b0
diff --git a/pom.xml b/pom.xml index 42e282d..ac5296a 100644 --- a/pom.xml +++ b/pom.xml
@@ -21,7 +21,7 @@ <groupId>gwtexpui</groupId> <artifactId>gwtexpui</artifactId> <packaging>jar</packaging> - <version>1.2.7</version> + <version>1.3</version> <name>gwtexpui</name> <description>Extended UI tools for GWT</description> <url>https://gerrit.googlesource.com/gwtexpui</url>
diff --git a/src/main/java/com/google/gwtexpui/server/CacheControlFilter.java b/src/main/java/com/google/gwtexpui/server/CacheControlFilter.java index 32345ac..c4d681f 100644 --- a/src/main/java/com/google/gwtexpui/server/CacheControlFilter.java +++ b/src/main/java/com/google/gwtexpui/server/CacheControlFilter.java
@@ -15,6 +15,7 @@ package com.google.gwtexpui.server; import java.io.IOException; +import java.util.concurrent.TimeUnit; import javax.servlet.Filter; import javax.servlet.FilterChain; @@ -61,16 +62,9 @@ final String pathInfo = pathInfo(req); if (cacheForever(pathInfo, req)) { - final long now = System.currentTimeMillis(); - rsp.setHeader("Cache-Control", "max-age=31536000,public"); - rsp.setDateHeader("Expires", now + 31536000000L); - rsp.setDateHeader("Date", now); - + CacheHeaders.setCacheable(req, rsp, 365, TimeUnit.DAYS); } else if (nocache(pathInfo)) { - rsp.setHeader("Expires", "Fri, 01 Jan 1980 00:00:00 GMT"); - rsp.setHeader("Pragma", "no-cache"); - rsp.setHeader("Cache-Control", "no-cache, must-revalidate"); - rsp.setDateHeader("Date", System.currentTimeMillis()); + CacheHeaders.setNotCacheable(rsp); } chain.doFilter(req, rsp);
diff --git a/src/main/java/com/google/gwtexpui/server/CacheHeaders.java b/src/main/java/com/google/gwtexpui/server/CacheHeaders.java new file mode 100644 index 0000000..11409e8 --- /dev/null +++ b/src/main/java/com/google/gwtexpui/server/CacheHeaders.java
@@ -0,0 +1,118 @@ +// Copyright (C) 2013 The Android Open Source Project +// +// Licensed 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. + +package com.google.gwtexpui.server; + +import static java.util.concurrent.TimeUnit.DAYS; +import static java.util.concurrent.TimeUnit.SECONDS; + +import java.util.concurrent.TimeUnit; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +/** Utilities to manage HTTP caching directives in responses. */ +public class CacheHeaders { + private static final long MAX_CACHE_DURATION = DAYS.toSeconds(365); + + /** + * Do not cache the response, anywhere. + * + * @param res response being returned. + */ + public static void setNotCacheable(HttpServletResponse res) { + String cc = "no-cache, no-store, max-age=0, must-revalidate"; + res.setHeader("Cache-Control", cc); + res.setHeader("Pragma", "no-cache"); + res.setHeader("Expires", "Fri, 01 Jan 1990 00:00:00 GMT"); + res.setDateHeader("Date", System.currentTimeMillis()); + } + + /** + * Permit caching the response for up to the age specified. + * <p> + * If the request is on a secure connection (e.g. SSL) private caching is + * used. This allows the user-agent to cache the response, but requests + * intermediate proxies to not cache. This may offer better protection for + * Set-Cookie headers. + * <p> + * If the request is on plaintext (insecure), public caching is used. This may + * allow an intermediate proxy to cache the response, including any Set-Cookie + * header that may have also been included. + * + * @param req current request. + * @param res response being returned. + * @param age how long the response can be cached. + * @param unit time unit for age, usually {@link TimeUnit#SECONDS}. + */ + public static void setCacheable( + HttpServletRequest req, HttpServletResponse res, + long age, TimeUnit unit) { + if (req.isSecure()) { + setCacheablePrivate(res, age, unit); + } else { + setCacheablePublic(res, age, unit); + } + } + + /** + * Allow the response to be cached by proxies and user-agents. + * <p> + * If the response includes a Set-Cookie header the cookie may be cached by a + * proxy and returned to multiple browsers behind the same proxy. This is + * insecure for authenticated connections. + * + * @param res response being returned. + * @param age how long the response can be cached. + * @param unit time unit for age, usually {@link TimeUnit#SECONDS}. + */ + public static void setCacheablePublic(HttpServletResponse res, + long age, TimeUnit unit) { + long now = System.currentTimeMillis(); + long sec = maxAgeSeconds(age, unit); + + res.setDateHeader("Expires", now + SECONDS.toMillis(sec)); + res.setDateHeader("Date", now); + cache(res, "public", age, unit); + } + + /** + * Allow the response to be cached only by the user-agent. + * + * @param res response being returned. + * @param age how long the response can be cached. + * @param unit time unit for age, usually {@link TimeUnit#SECONDS}. + */ + public static void setCacheablePrivate(HttpServletResponse res, + long age, TimeUnit unit) { + long now = System.currentTimeMillis(); + res.setDateHeader("Expires", now); + res.setDateHeader("Date", now); + cache(res, "private", age, unit); + } + + private static void cache(HttpServletResponse res, + String type, long age, TimeUnit unit) { + res.setHeader("Cache-Control", String.format( + "%s, max-age=%d", + type, maxAgeSeconds(age, unit))); + } + + private static long maxAgeSeconds(long age, TimeUnit unit) { + return Math.min(unit.toSeconds(age), MAX_CACHE_DURATION); + } + + private CacheHeaders() { + } +}