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);
+        }
+    }
+
 }

Reply via email to