This is an automated email from the ASF dual-hosted git repository.
coheigea pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/cxf.git
The following commit(s) were added to refs/heads/main by this push:
new 0d076e8d609 reject stale signed Date headers in MessageVerifier (#3680)
0d076e8d609 is described below
commit 0d076e8d609b49f03e54f24a89cce360ac0237f0
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
---
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 24cb585ea65..d80390175cc 100644
--- a/distribution/src/main/release/release_notes.txt
+++ b/distribution/src/main/release/release_notes.txt
@@ -33,6 +33,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/42-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);
+ }
+ }
+
}