This is an automated email from the ASF dual-hosted git repository. coheigea pushed a commit to branch 4.1.x-fixes in repository https://gitbox.apache.org/repos/asf/cxf.git
commit bd1b284b584ed540c64df4204034906fe7ff82e2 Author: Naveed Khan <[email protected]> AuthorDate: Fri Nov 13 15:17:19 2026 +0530 reject stale signed Date headers in MessageVerifier (#3680) * reject stale signed Date headers in MessageVerifier * resolve http signature date ttl from the message and check the signed date value * make http signature ttl setters bean properties and keep future ttl 0 strict (cherry picked from commit 0d076e8d609b49f03e54f24a89cce360ac0237f0) --- distribution/src/main/release/release_notes.txt | 11 ++ .../httpsignature/HTTPSignatureConstants.java | 23 ++++ .../rs/security/httpsignature/MessageVerifier.java | 118 ++++++++++++++++ .../httpsignature/utils/SignatureHeaderUtils.java | 6 +- .../httpsignature/MessageVerifierTest.java | 153 +++++++++++++++++++++ .../security/httpsignature/SpecExamplesTest.java | 44 +++--- .../utils/SignatureHeaderUtilsTest.java | 19 +++ 7 files changed, 348 insertions(+), 26 deletions(-) diff --git a/distribution/src/main/release/release_notes.txt b/distribution/src/main/release/release_notes.txt index b42d672255b..9653e182dc1 100644 --- a/distribution/src/main/release/release_notes.txt +++ b/distribution/src/main/release/release_notes.txt @@ -24,6 +24,17 @@ Important notes: must return a fresh stream positioned at the beginning. Persistence and retransmission may read the original attachment more than once, including when WS-Security signs or encrypts attachments. +* HTTP Signature: when an inbound request or response signs the "Date" header, + MessageVerifier now rejects it if the Date is more than 300 seconds old or + more than 60 seconds in the future. Deployments that sign "Date" with more + clock skew than this, or send fixed dates, will start failing. The limits can + be changed with "rs.security.http.signature.time.to.live" and + "rs.security.http.signature.future.time.to.live" (or the MessageVerifier + setters). A time to live of 0 or less disables the age check, a future time to + live of 0 allows no clock skew and a negative value disables the future check. + The check only gives replay protection when "date" is signed and listed in + "rs.security.http.signature.in.headers", and a message can still be replayed + within the time window. Users are encouraged to review the migration guide at: https://cxf.apache.org/docs/41-migration-guide.html diff --git a/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/HTTPSignatureConstants.java b/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/HTTPSignatureConstants.java index af262dd7325..25c79f5a7e2 100644 --- a/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/HTTPSignatureConstants.java +++ b/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/HTTPSignatureConstants.java @@ -52,6 +52,29 @@ public final class HTTPSignatureConstants extends RSSecurityConstants { */ public static final String RSSEC_HTTP_SIGNATURE_DIGEST_ALGORITHM = "rs.security.http.signature.digest.algorithm"; + /** + * The maximum age in seconds of a signed "Date" header on an inbound request or response. A message whose + * signed "Date" is older than this is rejected, so that a captured signed message can not be replayed + * after its time to live has passed. The default is 300 seconds, a value of 0 or less disables the check. + * A value set directly on the MessageVerifier takes precedence. + * + * The check only applies when the sender signs the "Date" header, which CreateSignatureInterceptor does not + * add by default. To get replay protection, the sender must sign "date" and the receiver must also add + * "date" to "rs.security.http.signature.in.headers" so that messages without a signed "Date" are rejected. + * There is no nonce or replay cache, so a message can still be replayed within the time to live. + */ + public static final String RSSEC_HTTP_SIGNATURE_TIME_TO_LIVE = "rs.security.http.signature.time.to.live"; + + /** + * The number of seconds a signed "Date" header on an inbound request or response may be in the future, + * to allow for clock skew. The default is 60 seconds, a value of 0 allows no clock skew and a negative value + * disables the check. With the check disabled, a message with a signed "Date" in the future stays within the + * time to live until that date. A value set directly on the MessageVerifier takes precedence. See + * RSSEC_HTTP_SIGNATURE_TIME_TO_LIVE for the limits of this check. + */ + public static final String RSSEC_HTTP_SIGNATURE_FUTURE_TIME_TO_LIVE = + "rs.security.http.signature.future.time.to.live"; + private HTTPSignatureConstants() { // complete diff --git a/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/MessageVerifier.java b/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/MessageVerifier.java index 0402c81602d..0d16eb57e21 100644 --- a/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/MessageVerifier.java +++ b/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/MessageVerifier.java @@ -18,17 +18,21 @@ */ package org.apache.cxf.rs.security.httpsignature; +import java.text.ParseException; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.concurrent.TimeUnit; import java.util.logging.Logger; import org.apache.cxf.common.logging.LogUtils; import org.apache.cxf.helpers.CastUtils; +import org.apache.cxf.jaxrs.utils.HttpUtils; import org.apache.cxf.message.Message; import org.apache.cxf.message.MessageUtils; +import org.apache.cxf.rs.security.httpsignature.exception.InvalidSignatureException; import org.apache.cxf.rs.security.httpsignature.exception.MissingSignatureHeaderException; import org.apache.cxf.rs.security.httpsignature.exception.MultipleSignatureHeaderException; import org.apache.cxf.rs.security.httpsignature.provider.AlgorithmProvider; @@ -36,8 +40,18 @@ import org.apache.cxf.rs.security.httpsignature.provider.KeyProvider; import org.apache.cxf.rs.security.httpsignature.provider.SecurityProvider; import org.apache.cxf.rs.security.httpsignature.utils.DefaultSignatureConstants; import org.apache.cxf.rs.security.httpsignature.utils.SignatureHeaderUtils; +import org.tomitribe.auth.signatures.Signature; public class MessageVerifier { + /** + * The default maximum age in seconds of a signed "Date" header + */ + public static final int DEFAULT_TIME_TO_LIVE = 300; + /** + * The default number of seconds a signed "Date" header may be in the future + */ + public static final int DEFAULT_FUTURE_TIME_TO_LIVE = 60; + private static final Logger LOG = LogUtils.getL7dLogger(MessageVerifier.class); private AlgorithmProvider algorithmProvider; @@ -46,6 +60,8 @@ public class MessageVerifier { private final SignatureValidator signatureValidator; private final List<String> requiredHeaders; private boolean addDefaultRequiredHeaders = true; + private Integer timeToLive; + private Integer futureTimeToLive; public MessageVerifier(KeyProvider keyProvider) { this(keyProvider, (List<String>)null); @@ -151,9 +167,74 @@ public class MessageVerifier { method, uri, signedHeaders); + verifyDateHeader(messageHeaders, m); LOG.fine("Finished signature verification"); } + /** + * Reject a message whose signed "Date" header is outside the configured time window, so that a captured + * signed message can not be replayed once its time to live has passed. A "Date" header which is not + * covered by the signature is ignored, as it can be changed along with the rest of the unsigned message. + * Values set on this class take precedence over the contextual properties. + */ + private void verifyDateHeader(Map<String, List<String>> messageHeaders, Message m) { + int ttl = timeToLive != null ? timeToLive + : getContextualInteger(m, HTTPSignatureConstants.RSSEC_HTTP_SIGNATURE_TIME_TO_LIVE, DEFAULT_TIME_TO_LIVE); + int futureTtl = futureTimeToLive != null ? futureTimeToLive + : getContextualInteger(m, HTTPSignatureConstants.RSSEC_HTTP_SIGNATURE_FUTURE_TIME_TO_LIVE, + DEFAULT_FUTURE_TIME_TO_LIVE); + // A time to live of 0 would reject every message, so 0 or less disables the age check. For the future + // check 0 means no clock skew is allowed and only a negative value disables it. + if (ttl <= 0 && futureTtl < 0) { + return; + } + List<String> signedHeaders = Signature.fromString(messageHeaders.get("Signature").get(0)).getHeaders(); + if (!signedHeaders.contains("date")) { + return; + } + // Check the same value that was signed, see SignatureHeaderUtils.mapHeaders + List<String> dates = new ArrayList<>(); + for (Map.Entry<String, List<String>> entry : messageHeaders.entrySet()) { + if ("date".equalsIgnoreCase(entry.getKey())) { + dates.addAll(entry.getValue()); + } + } + if (dates.isEmpty()) { + return; + } + if (dates.size() > 1) { + throw new InvalidSignatureException("there are multiple signed Date header values"); + } + final long dateTime; + try { + dateTime = HttpUtils.getHttpDateFormat().parse(dates.get(0)).getTime(); + } catch (ParseException ex) { + throw new InvalidSignatureException("the signed Date header can not be parsed"); + } + long now = System.currentTimeMillis(); + if (ttl > 0 && now - dateTime > TimeUnit.SECONDS.toMillis(ttl)) { + throw new InvalidSignatureException("the signed Date header is older than the time to live"); + } + if (futureTtl >= 0 && dateTime - now > TimeUnit.SECONDS.toMillis(futureTtl)) { + throw new InvalidSignatureException("the signed Date header is in the future"); + } + } + + private static int getContextualInteger(Message m, String key, int defaultValue) { + Object value = m.getContextualProperty(key); + if (value instanceof Number) { + return ((Number)value).intValue(); + } + if (value instanceof String) { + try { + return Integer.parseInt((String)value); + } catch (NumberFormatException ex) { + LOG.warning("Incorrect integer value of " + value + " specified for: " + key); + } + } + return defaultValue; + } + private void inspectMultipleSignatureHeaders(Map<String, List<String>> responseHeaders) { if (responseHeaders.get("Signature").size() > 1) { throw new MultipleSignatureHeaderException("there are multiple signature headers in request"); @@ -178,4 +259,41 @@ public class MessageVerifier { this.addDefaultRequiredHeaders = addDefaultRequiredHeaders; } + /** + * Return the configured maximum age in seconds of a signed "Date" header, or null if it was not set on + * this class, in which case the contextual property or the default of 300 seconds is used. + */ + public Integer getTimeToLive() { + return timeToLive; + } + + /** + * Set the maximum age in seconds of a signed "Date" header. A message whose signed "Date" is older + * than this is rejected. This takes precedence over the "rs.security.http.signature.time.to.live" + * contextual property. The default is 300 seconds, a value of 0 or less disables the check, and null + * falls back to the contextual property. + */ + public void setTimeToLive(Integer timeToLive) { + this.timeToLive = timeToLive; + } + + /** + * Return the configured number of seconds a signed "Date" header may be in the future, or null if it was + * not set on this class, in which case the contextual property or the default of 60 seconds is used. + */ + public Integer getFutureTimeToLive() { + return futureTimeToLive; + } + + /** + * Set the number of seconds a signed "Date" header may be in the future, to allow for clock skew. + * This takes precedence over the "rs.security.http.signature.future.time.to.live" contextual property. + * The default is 60 seconds, a value of 0 allows no clock skew, a negative value disables the check, and + * null falls back to the contextual property. With the check disabled, a message with a signed "Date" in + * the future stays within the time to live until that date. + */ + public void setFutureTimeToLive(Integer futureTimeToLive) { + this.futureTimeToLive = futureTimeToLive; + } + } diff --git a/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/utils/SignatureHeaderUtils.java b/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/utils/SignatureHeaderUtils.java index e4a6f248961..68c52c6d64b 100644 --- a/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/utils/SignatureHeaderUtils.java +++ b/rt/rs/security/http-signature/src/main/java/org/apache/cxf/rs/security/httpsignature/utils/SignatureHeaderUtils.java @@ -21,9 +21,8 @@ package org.apache.cxf.rs.security.httpsignature.utils; import java.net.URI; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; -import java.time.Clock; -import java.time.LocalDateTime; import java.time.ZoneOffset; +import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Base64; import java.util.Collections; @@ -42,8 +41,7 @@ public final class SignatureHeaderUtils { * Add a date header at the current time using the ZoneOffset. Date format is http */ public static void addDateHeader(Map<String, List<String>> messageHeaders, ZoneOffset zoneOffset) { - String date = DateTimeFormatter.RFC_1123_DATE_TIME - .format(LocalDateTime.now().atZone(Clock.system(zoneOffset).getZone())); + String date = DateTimeFormatter.RFC_1123_DATE_TIME.format(ZonedDateTime.now(zoneOffset)); messageHeaders.put("Date", Collections.singletonList(date)); } diff --git a/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/MessageVerifierTest.java b/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/MessageVerifierTest.java index 002000f5caf..2ef63c6261e 100644 --- a/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/MessageVerifierTest.java +++ b/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/MessageVerifierTest.java @@ -18,12 +18,17 @@ */ package org.apache.cxf.rs.security.httpsignature; +import java.beans.Introspector; +import java.beans.PropertyDescriptor; import java.io.IOException; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; @@ -32,6 +37,7 @@ import java.util.Map; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; +import org.apache.cxf.message.Message; import org.apache.cxf.message.MessageImpl; import org.apache.cxf.rs.security.httpsignature.exception.DifferentAlgorithmsException; import org.apache.cxf.rs.security.httpsignature.exception.InvalidDataToVerifySignatureException; @@ -46,6 +52,10 @@ import org.apache.cxf.rs.security.httpsignature.utils.SignatureHeaderUtils; import org.junit.BeforeClass; import org.junit.Test; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.fail; + public class MessageVerifierTest { private static final String KEY_ID = "testVerifier"; private static final String METHOD = "GET"; @@ -285,6 +295,149 @@ public class MessageVerifierTest { headerVerifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), null); } + @Test(expected = InvalidSignatureException.class) + public void staleSignedDateHeaderFails() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(-10))); + createAndAddSignature(headers); + messageVerifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + @Test(expected = InvalidSignatureException.class) + public void futureSignedDateHeaderFails() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(10))); + createAndAddSignature(headers); + messageVerifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + @Test + public void signedDateHeaderWithinTimeToLivePasses() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(-4))); + createAndAddSignature(headers); + messageVerifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + @Test + public void staleUnsignedDateHeaderIsIgnored() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(-10))); + new MessageSigner(keyId -> keyPair.getPrivate(), KEY_ID, Collections.singletonList("host")) + .sign(headers, URI, METHOD); + messageVerifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + @Test + public void staleSignedDateHeaderPassesWithoutTimeToLive() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(-10))); + createAndAddSignature(headers); + + MessageVerifier noTtlVerifier = new MessageVerifier(keyId -> keyPair.getPublic()); + noTtlVerifier.setSecurityProvider(new MockSecurityProvider()); + noTtlVerifier.setAlgorithmProvider(new MockAlgorithmProvider()); + noTtlVerifier.setAddDefaultRequiredHeaders(false); + noTtlVerifier.setTimeToLive(0); + noTtlVerifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + @Test(expected = InvalidSignatureException.class) + public void staleSignedDateHeaderFailsWithContextualTimeToLive() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(-4))); + createAndAddSignature(headers); + Message message = new MessageImpl(); + message.put(HTTPSignatureConstants.RSSEC_HTTP_SIGNATURE_TIME_TO_LIVE, "120"); + messageVerifier.verifyMessage(headers, METHOD, URI, message, MESSAGE_BODY.getBytes()); + } + + @Test + public void explicitTimeToLiveTakesPrecedence() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(-10))); + createAndAddSignature(headers); + + MessageVerifier verifier = new MessageVerifier(keyId -> keyPair.getPublic()); + verifier.setSecurityProvider(new MockSecurityProvider()); + verifier.setAlgorithmProvider(new MockAlgorithmProvider()); + verifier.setAddDefaultRequiredHeaders(false); + verifier.setTimeToLive(900); + Message message = new MessageImpl(); + message.put(HTTPSignatureConstants.RSSEC_HTTP_SIGNATURE_TIME_TO_LIVE, "120"); + verifier.verifyMessage(headers, METHOD, URI, message, MESSAGE_BODY.getBytes()); + } + + @Test(expected = InvalidSignatureException.class) + public void multipleSignedDateHeaderValuesFail() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Arrays.asList(httpDate(0), httpDate(-10))); + createAndAddSignature(headers); + messageVerifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + @Test(expected = InvalidSignatureException.class) + public void futureSignedDateHeaderFailsWithZeroFutureTimeToLive() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(1))); + createAndAddSignature(headers); + + MessageVerifier verifier = new MessageVerifier(keyId -> keyPair.getPublic()); + verifier.setSecurityProvider(new MockSecurityProvider()); + verifier.setAlgorithmProvider(new MockAlgorithmProvider()); + verifier.setAddDefaultRequiredHeaders(false); + verifier.setFutureTimeToLive(0); + verifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + @Test + public void futureSignedDateHeaderPassesWithNegativeFutureTimeToLive() throws IOException { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(10))); + createAndAddSignature(headers); + + MessageVerifier verifier = new MessageVerifier(keyId -> keyPair.getPublic()); + verifier.setSecurityProvider(new MockSecurityProvider()); + verifier.setAlgorithmProvider(new MockAlgorithmProvider()); + verifier.setAddDefaultRequiredHeaders(false); + verifier.setFutureTimeToLive(-1); + verifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + @Test + public void timeToLiveCanBeSetAsBeanProperties() throws Exception { + Map<String, List<String>> headers = createMockHeaders(); + headers.put("Date", Collections.singletonList(httpDate(-10))); + createAndAddSignature(headers); + + MessageVerifier verifier = new MessageVerifier(keyId -> keyPair.getPublic()); + verifier.setSecurityProvider(new MockSecurityProvider()); + verifier.setAlgorithmProvider(new MockAlgorithmProvider()); + verifier.setAddDefaultRequiredHeaders(false); + setBeanProperty(verifier, "timeToLive", 900); + setBeanProperty(verifier, "futureTimeToLive", 0); + assertEquals(Integer.valueOf(900), verifier.getTimeToLive()); + assertEquals(Integer.valueOf(0), verifier.getFutureTimeToLive()); + verifier.verifyMessage(headers, METHOD, URI, new MessageImpl(), MESSAGE_BODY.getBytes()); + } + + // Set the property the way Spring/Blueprint bean configuration does, through JavaBeans introspection + private static void setBeanProperty(Object bean, String name, Object value) throws Exception { + for (PropertyDescriptor pd : Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors()) { + if (name.equals(pd.getName())) { + assertNotNull(name + " is not writable", pd.getWriteMethod()); + pd.getWriteMethod().invoke(bean, value); + return; + } + } + fail("no bean property " + name); + } + + private static String httpDate(int minutesFromNow) { + return DateTimeFormatter.RFC_1123_DATE_TIME.format( + ZonedDateTime.now(ZoneOffset.UTC).plusMinutes(minutesFromNow)); + } + private static void createAndAddSignature(Map<String, List<String>> headers) throws IOException { messageSigner.sign(headers, URI, METHOD); } diff --git a/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/SpecExamplesTest.java b/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/SpecExamplesTest.java index 6da1dcb59a4..003fbf7e8f1 100644 --- a/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/SpecExamplesTest.java +++ b/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/SpecExamplesTest.java @@ -34,6 +34,7 @@ import java.security.PublicKey; import java.security.spec.InvalidKeySpecException; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; +import java.time.ZoneOffset; import java.util.Arrays; import java.util.Collection; import java.util.Collections; @@ -66,6 +67,7 @@ import org.apache.cxf.rs.security.httpsignature.filters.VerifySignatureFilter; import org.apache.cxf.rs.security.httpsignature.provider.KeyProvider; import org.apache.cxf.rs.security.httpsignature.provider.MockAlgorithmProvider; import org.apache.cxf.rs.security.httpsignature.provider.MockSecurityProvider; +import org.apache.cxf.rs.security.httpsignature.utils.SignatureHeaderUtils; import org.junit.Before; import org.junit.BeforeClass; @@ -137,10 +139,8 @@ public class SpecExamplesTest { // Now check we validate the Date header as expected on an empty header list headers.put("Signature", Collections.singletonList(expectedHeader)); - MessageVerifier messageVerifier = new MessageVerifier(keyId -> publicKey); + MessageVerifier messageVerifier = createSpecExampleVerifier(); messageVerifier.setAddDefaultRequiredHeaders(false); - messageVerifier.setSecurityProvider(new MockSecurityProvider()); - messageVerifier.setAlgorithmProvider(new MockAlgorithmProvider()); messageVerifier.verifyMessage(headers, "POST", "/foo?param=value&pet=dog", new MessageImpl(), MESSAGE_BODY.getBytes()); } @@ -178,10 +178,8 @@ public class SpecExamplesTest { assertEquals(signatureHeader.replaceAll("headers=\"date\",", ""), expectedHeader); // Verify that the request signature can be verified by the filter - MessageVerifier messageVerifier = new MessageVerifier(keyId -> publicKey); + MessageVerifier messageVerifier = createSpecExampleVerifier(); messageVerifier.setAddDefaultRequiredHeaders(false); - messageVerifier.setSecurityProvider(new MockSecurityProvider()); - messageVerifier.setAlgorithmProvider(new MockAlgorithmProvider()); VerifySignatureFilter verifySignatureFilter = new VerifySignatureFilter(); verifySignatureFilter.setMessageVerifier(messageVerifier); @@ -211,10 +209,8 @@ public class SpecExamplesTest { assertEquals(signatureHeader, expectedHeader); - MessageVerifier messageVerifier = new MessageVerifier(keyId -> publicKey); + MessageVerifier messageVerifier = createSpecExampleVerifier(); messageVerifier.setAddDefaultRequiredHeaders(false); - messageVerifier.setSecurityProvider(new MockSecurityProvider()); - messageVerifier.setAlgorithmProvider(new MockAlgorithmProvider()); messageVerifier.verifyMessage(headers, "POST", "/foo?param=value&pet=dog", new MessageImpl(), MESSAGE_BODY.getBytes()); } @@ -255,10 +251,8 @@ public class SpecExamplesTest { assertEquals(signatureHeader, expectedHeader); // Verify that the request signature can be verified by the filter - MessageVerifier messageVerifier = new MessageVerifier(keyId -> publicKey); + MessageVerifier messageVerifier = createSpecExampleVerifier(); messageVerifier.setAddDefaultRequiredHeaders(false); - messageVerifier.setSecurityProvider(new MockSecurityProvider()); - messageVerifier.setAlgorithmProvider(new MockAlgorithmProvider()); VerifySignatureFilter verifySignatureFilter = new VerifySignatureFilter(); verifySignatureFilter.setMessageVerifier(messageVerifier); @@ -288,9 +282,7 @@ public class SpecExamplesTest { assertEquals(signatureHeader, expectedHeader); - MessageVerifier messageVerifier = new MessageVerifier(keyId -> publicKey); - messageVerifier.setSecurityProvider(new MockSecurityProvider()); - messageVerifier.setAlgorithmProvider(new MockAlgorithmProvider()); + MessageVerifier messageVerifier = createSpecExampleVerifier(); messageVerifier.verifyMessage(headers, "POST", "/foo?param=value&pet=dog", new MessageImpl(), MESSAGE_BODY.getBytes()); } @@ -332,10 +324,8 @@ public class SpecExamplesTest { assertEquals(signatureHeader, expectedHeader); // Verify that the request signature can be verified by the filter - MessageVerifier messageVerifier = new MessageVerifier(keyId -> publicKey); + MessageVerifier messageVerifier = createSpecExampleVerifier(); messageVerifier.setAddDefaultRequiredHeaders(false); - messageVerifier.setSecurityProvider(new MockSecurityProvider()); - messageVerifier.setAlgorithmProvider(new MockAlgorithmProvider()); VerifySignatureFilter verifySignatureFilter = new VerifySignatureFilter(); verifySignatureFilter.setMessageVerifier(messageVerifier); @@ -357,7 +347,7 @@ public class SpecExamplesTest { // The client signs a DELETE without a body, so no digest is added or signed Map<String, List<String>> headers = new HashMap<>(); headers.put("Host", Collections.singletonList("example.com")); - headers.put("Date", Collections.singletonList("Sun, 05 Jan 2014 21:31:40 GMT")); + SignatureHeaderUtils.addDateHeader(headers, ZoneOffset.UTC); MessageSigner messageSigner = new MessageSigner(keyProvider, "Test", Arrays.asList("(request-target)", "host", "date")); messageSigner.sign(headers, "/foo/1", method); @@ -391,7 +381,7 @@ public class SpecExamplesTest { public void clientFilterUnsignedResponseBodyTest() throws IOException { // The service signs a response without a body, so no digest is added or signed Map<String, List<String>> headers = new HashMap<>(); - headers.put("Date", Collections.singletonList("Sun, 05 Jan 2014 21:31:40 GMT")); + SignatureHeaderUtils.addDateHeader(headers, ZoneOffset.UTC); MessageSigner messageSigner = new MessageSigner(keyProvider, "Test"); messageSigner.sign(headers, "", ""); @@ -428,7 +418,7 @@ public class SpecExamplesTest { // The client signs a GET without a body, so no digest is added or signed Map<String, List<String>> headers = new HashMap<>(); headers.put("Host", Collections.singletonList("example.com")); - headers.put("Date", Collections.singletonList("Sun, 05 Jan 2014 21:31:40 GMT")); + SignatureHeaderUtils.addDateHeader(headers, ZoneOffset.UTC); MessageSigner messageSigner = new MessageSigner(keyProvider, "Test", Arrays.asList("(request-target)", "host", "date")); messageSigner.sign(headers, "/foo/1", method); @@ -462,7 +452,7 @@ public class SpecExamplesTest { public void clientFilterUnsignedErrorResponseBodyTest() throws IOException { // The service signs a response without a body, so no digest is added or signed Map<String, List<String>> headers = new HashMap<>(); - headers.put("Date", Collections.singletonList("Sun, 05 Jan 2014 21:31:40 GMT")); + SignatureHeaderUtils.addDateHeader(headers, ZoneOffset.UTC); MessageSigner messageSigner = new MessageSigner(keyProvider, "Test"); messageSigner.sign(headers, "", ""); @@ -500,6 +490,16 @@ public class SpecExamplesTest { return result.get(); } + // The spec examples carry a fixed Date from 2014, so the signed Date checks are disabled + private static MessageVerifier createSpecExampleVerifier() { + MessageVerifier messageVerifier = new MessageVerifier(keyId -> publicKey); + messageVerifier.setSecurityProvider(new MockSecurityProvider()); + messageVerifier.setAlgorithmProvider(new MockAlgorithmProvider()); + messageVerifier.setTimeToLive(0); + messageVerifier.setFutureTimeToLive(-1); + return messageVerifier; + } + private VerifySignatureFilter createVerifySignatureFilter() { MessageVerifier messageVerifier = new MessageVerifier(keyId -> publicKey); messageVerifier.setSecurityProvider(new MockSecurityProvider()); diff --git a/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/utils/SignatureHeaderUtilsTest.java b/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/utils/SignatureHeaderUtilsTest.java index 73127258d1a..36c40313ef2 100644 --- a/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/utils/SignatureHeaderUtilsTest.java +++ b/rt/rs/security/http-signature/src/test/java/org/apache/cxf/rs/security/httpsignature/utils/SignatureHeaderUtilsTest.java @@ -18,9 +18,17 @@ */ package org.apache.cxf.rs.security.httpsignature.utils; +import java.text.ParseException; +import java.time.ZoneOffset; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.cxf.jaxrs.utils.HttpUtils; import org.apache.cxf.rs.security.httpsignature.exception.DigestFailureException; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; public class SignatureHeaderUtilsTest { @@ -59,4 +67,15 @@ public class SignatureHeaderUtilsTest { SignatureHeaderUtils.createDigestHeader("xyz", "SHA-1"); } + @org.junit.Test + public void testAddDateHeaderIsCurrentTime() throws ParseException { + // The header must hold the current instant whatever the system time zone and the requested offset + for (ZoneOffset offset : new ZoneOffset[] {ZoneOffset.UTC, ZoneOffset.ofHours(-7), ZoneOffset.ofHours(9)}) { + Map<String, List<String>> headers = new HashMap<>(); + SignatureHeaderUtils.addDateHeader(headers, offset); + long date = HttpUtils.getHttpDateFormat().parse(headers.get("Date").get(0)).getTime(); + assertTrue(Math.abs(System.currentTimeMillis() - date) < 60000L); + } + } + }
