This is an automated email from the ASF dual-hosted git repository.

snoopdave pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/roller.git


The following commit(s) were added to refs/heads/master by this push:
     new 8a15bed51 Separate submitted and response salts in UI filters (#167)
8a15bed51 is described below

commit 8a15bed514887911cb220b15b3e0bc7b64226fc9
Author: David M. Johnson <[email protected]>
AuthorDate: Sat Sep 5 16:09:12 2026 -0400

    Separate submitted and response salts in UI filters (#167)
    
    * Separate submitted and response salts in UI filters
    
    Validate the salt submitted with the request rather than a request 
attribute, and run validation before the response salt is generated. Move 
multipart validation into a Struts interceptor after the upload interceptor, 
since filters cannot read multipart fields. Drop the unused salt.ignored.urls 
bypass.
    
    Claude-Session: https://claude.ai/code/session_01A1fhY1E2PCFU6UAPXu2WtV
    
    * Handle chained and repeated salt-validated requests
    
    * Look up the session user only when a salt was submitted
    
    Hoist the authenticated user into a local so it is fetched once instead
    of twice, and move that lookup below the early return for a request that
    submitted no salt, where its result is unused.
    
    Claude-Session: https://claude.ai/code/session_019R1jdtwkaYEeA6L9DXEtEi
---
 .../weblogger/ui/core/filters/SaltValidator.java   | 110 +++++++++++
 .../ui/core/filters/ValidateSaltFilter.java        |  59 ++----
 .../ui/struts2/ajax/CommentDataServlet.java        |  45 +++--
 .../ui/struts2/util/ValidateSaltInterceptor.java   |  71 +++++++
 .../roller/weblogger/config/roller.properties      |   3 -
 app/src/main/resources/struts.xml                  |   3 +
 .../main/webapp/WEB-INF/jsps/editor/Comments.jsp   |  22 ++-
 app/src/main/webapp/WEB-INF/web.xml                |   8 +-
 .../ui/core/filters/SaltConfigurationTest.java     |  79 ++++++++
 .../ui/core/filters/ValidateSaltFilterTest.java    |  89 ++++++---
 .../ui/struts2/ajax/CommentDataServletTest.java    | 165 ++++++++++++++++
 .../struts2/util/ValidateSaltInterceptorTest.java  | 219 +++++++++++++++++++++
 12 files changed, 782 insertions(+), 91 deletions(-)

diff --git 
a/app/src/main/java/org/apache/roller/weblogger/ui/core/filters/SaltValidator.java
 
b/app/src/main/java/org/apache/roller/weblogger/ui/core/filters/SaltValidator.java
new file mode 100644
index 000000000..e1dba53f7
--- /dev/null
+++ 
b/app/src/main/java/org/apache/roller/weblogger/ui/core/filters/SaltValidator.java
@@ -0,0 +1,110 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.  For additional information regarding
+ * copyright in this work, please see the NOTICE file in the top level
+ * directory of this distribution.
+ */
+
+package org.apache.roller.weblogger.ui.core.filters;
+
+import java.util.Locale;
+import java.util.Objects;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.roller.weblogger.pojos.User;
+import org.apache.roller.weblogger.ui.core.RollerSession;
+import org.apache.roller.weblogger.ui.rendering.util.cache.SaltCache;
+
+/**
+ * Shared validation for salts submitted by UI forms.
+ */
+public final class SaltValidator {
+
+    private static final String MULTIPART_FORM_DATA = "multipart/form-data";
+
+    public static final String VALIDATED_REQUEST_ATTRIBUTE =
+            SaltValidator.class.getName() + ".validated";
+
+    private SaltValidator() {
+    }
+
+    /**
+     * Validates and consumes the salt submitted as a request parameter.
+     *
+     * @param request current request
+     * @return true when no Roller session is present or the submitted salt is 
valid
+     */
+    public static boolean consumeSubmittedSalt(HttpServletRequest request) {
+        RollerSession rollerSession = RollerSession.getRollerSession(request);
+        if (rollerSession == null) {
+            return true;
+        }
+
+        String salt = request.getParameter("salt");
+        if (salt == null) {
+            return false;
+        }
+
+        User authenticatedUser = rollerSession.getAuthenticatedUser();
+        String userId = authenticatedUser != null ? authenticatedUser.getId() 
: "";
+
+        SaltCache saltCache = SaltCache.getInstance();
+        synchronized (saltCache) {
+            if (!Objects.equals(saltCache.get(salt), userId)) {
+                return false;
+            }
+            saltCache.remove(salt);
+        }
+        return true;
+    }
+
+    /**
+     * Validates and consumes the submitted salt or rejects the request.
+     *
+     * @param request current request
+     * @throws ServletException when the submitted salt is missing or invalid
+     */
+    public static void requireSubmittedSalt(HttpServletRequest request)
+            throws ServletException {
+        if (!consumeSubmittedSalt(request)) {
+            throw new ServletException("Security Violation");
+        }
+    }
+
+    /**
+     * Returns true for a multipart form POST, which Struts parses after the
+     * servlet filters have run.
+     *
+     * @param request current request
+     * @return true for multipart/form-data POST requests
+     */
+    public static boolean isMultipartFormPost(HttpServletRequest request) {
+        if (!"POST".equalsIgnoreCase(request.getMethod())) {
+            return false;
+        }
+
+        String contentType = request.getContentType();
+        if (contentType == null) {
+            return false;
+        }
+
+        int parameterStart = contentType.indexOf(';');
+        String mediaType = parameterStart >= 0
+                ? contentType.substring(0, parameterStart) : contentType;
+        return 
MULTIPART_FORM_DATA.equals(mediaType.trim().toLowerCase(Locale.ENGLISH));
+    }
+}
diff --git 
a/app/src/main/java/org/apache/roller/weblogger/ui/core/filters/ValidateSaltFilter.java
 
b/app/src/main/java/org/apache/roller/weblogger/ui/core/filters/ValidateSaltFilter.java
index 586bff185..78a32474b 100644
--- 
a/app/src/main/java/org/apache/roller/weblogger/ui/core/filters/ValidateSaltFilter.java
+++ 
b/app/src/main/java/org/apache/roller/weblogger/ui/core/filters/ValidateSaltFilter.java
@@ -19,9 +19,6 @@
 package org.apache.roller.weblogger.ui.core.filters;
 
 import java.io.IOException;
-import java.util.Collections;
-import java.util.Objects;
-import java.util.Set;
 
 import javax.servlet.Filter;
 import javax.servlet.FilterChain;
@@ -31,12 +28,8 @@ import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.http.HttpServletRequest;
 
-import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.apache.roller.weblogger.config.WebloggerConfig;
-import org.apache.roller.weblogger.ui.rendering.util.cache.SaltCache;
-import org.apache.roller.weblogger.ui.core.RollerSession;
 
 /**
  * Filter checks all POST request for presence of valid salt value and rejects 
those without
@@ -44,40 +37,28 @@ import org.apache.roller.weblogger.ui.core.RollerSession;
  */
 public class ValidateSaltFilter implements Filter {
     private static final Log log = LogFactory.getLog(ValidateSaltFilter.class);
-    private Set<String> ignored = Collections.emptySet();
 
     @Override
     public void doFilter(ServletRequest request, ServletResponse response,
             FilterChain chain) throws IOException, ServletException {
         HttpServletRequest httpReq = (HttpServletRequest) request;
 
-        String requestURL = httpReq.getRequestURL().toString();
-        String queryString = httpReq.getQueryString();
-        if (queryString != null) {
-            requestURL += "?" + queryString;
-        }
-
-        if ("POST".equals(httpReq.getMethod()) && !isIgnoredURL(requestURL)) {
-            RollerSession rollerSession = 
RollerSession.getRollerSession(httpReq);
-            if (rollerSession != null) {
-                String userId = rollerSession.getAuthenticatedUser() != null ? 
rollerSession.getAuthenticatedUser().getId() : "";
-
-                Object saltObject = httpReq.getAttribute("salt"); // 
multi-form post case
-                String salt = saltObject != null ? saltObject.toString() : 
null;
-                salt = salt != null ? salt : httpReq.getParameter("salt");
-                SaltCache saltCache = SaltCache.getInstance();
-                if (salt == null || !Objects.equals(saltCache.get(salt), 
userId)) {
-                    if (log.isDebugEnabled()) {
-                        log.debug("Valid salt value not found on POST to URL : 
" + httpReq.getServletPath());
-                    }
-                    throw new ServletException("Security Violation");
-                }
+        if ("POST".equalsIgnoreCase(httpReq.getMethod())) {
+            if (SaltValidator.isMultipartFormPost(httpReq) && 
isStrutsAction(httpReq)) {
+                // Struts wraps multipart requests before its interceptor 
stack;
+                // ValidateSaltInterceptor handles these requests.
+                chain.doFilter(request, response);
+                return;
+            }
 
-                // Remove salt from cache after successful validation
-                saltCache.remove(salt);
+            try {
+                SaltValidator.requireSubmittedSalt(httpReq);
+            } catch (ServletException e) {
                 if (log.isDebugEnabled()) {
-                    log.debug("Salt used and invalidated: " + salt);
+                    log.debug("Valid salt value not found on POST to URL : "
+                            + httpReq.getServletPath());
                 }
+                throw e;
             }
         }
 
@@ -86,20 +67,14 @@ public class ValidateSaltFilter implements Filter {
 
     @Override
     public void init(FilterConfig filterConfig) throws ServletException {
-        String urls = WebloggerConfig.getProperty("salt.ignored.urls");
-        ignored = Set.of(StringUtils.stripAll(StringUtils.split(urls, ",")));
     }
 
     @Override
     public void destroy() {
     }
 
-    /**
-     * Checks if this is an ignored url defined in the salt.ignored.urls 
property
-     * @param theUrl the url
-     * @return true, if is ignored resource
-     */
-    private boolean isIgnoredURL(String theUrl) {
-        return ignored.contains(theUrl);
+    private boolean isStrutsAction(HttpServletRequest request) {
+        String servletPath = request.getServletPath();
+        return servletPath != null && servletPath.endsWith(".rol");
     }
-}
\ No newline at end of file
+}
diff --git 
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/ajax/CommentDataServlet.java
 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/ajax/CommentDataServlet.java
index 59db62bd7..6868c27eb 100644
--- 
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/ajax/CommentDataServlet.java
+++ 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/ajax/CommentDataServlet.java
@@ -98,7 +98,8 @@ public class CommentDataServlet extends HttpServlet {
             WeblogEntryManager wmgr = roller.getWeblogEntryManager();
             WeblogEntryComment c = wmgr.getComment(request.getParameter("id"));
             if (c == null) {
-                response.setStatus(HttpServletResponse.SC_NOT_FOUND);
+                writeSaveResponse(request, response,
+                        HttpServletResponse.SC_NOT_FOUND, null, null);
             } else {
                 // need post permission to edit comments
                 RollerSession rses = RollerSession.getRollerSession(request);
@@ -114,17 +115,11 @@ public class CommentDataServlet extends HttpServlet {
                     c = wmgr.getComment(request.getParameter("id"));
                     content = Utilities.escapeHTML(c.getContent());
                     content = WordUtils.wrap(content, 72);
-                    content = StringEscapeUtils.escapeEcmaScript(content);
-                    String json = "{ id: \"" + c.getId() + "\"," + "content: 
\"" + content + "\" }";
-                    response.setStatus(HttpServletResponse.SC_OK);
-                    response.setContentType("text/html; charset=utf-8");
-                    response.getWriter().print(json);
-                    response.flushBuffer();
-                    response.getWriter().flush();
-                    response.getWriter().close();
-                    response.setStatus(HttpServletResponse.SC_OK);
+                    writeSaveResponse(request, response,
+                            HttpServletResponse.SC_OK, c.getId(), content);
                 } else {
-                    response.setStatus(HttpServletResponse.SC_FORBIDDEN);
+                    writeSaveResponse(request, response,
+                            HttpServletResponse.SC_FORBIDDEN, null, null);
                 }
             }
 
@@ -140,4 +135,32 @@ public class CommentDataServlet extends HttpServlet {
         // not all browsers support PUT
         doPut(request, response);
     }
+
+    private void writeSaveResponse(HttpServletRequest request,
+            HttpServletResponse response, int status, String id, String 
content)
+            throws IOException {
+        String salt = request.getAttribute("salt") != null
+                ? request.getAttribute("salt").toString() : "";
+        StringBuilder json = new StringBuilder("{");
+        if (id != null) {
+            json.append("\"id\":\"")
+                    .append(StringEscapeUtils.escapeJson(id))
+                    .append("\",");
+        }
+        if (content != null) {
+            json.append("\"content\":\"")
+                    .append(StringEscapeUtils.escapeJson(content))
+                    .append("\",");
+        }
+        json.append("\"salt\":\"")
+                .append(StringEscapeUtils.escapeJson(salt))
+                .append("\"}");
+
+        response.setStatus(status);
+        response.setContentType("application/json; charset=utf-8");
+        response.getWriter().print(json.toString());
+        response.flushBuffer();
+        response.getWriter().flush();
+        response.getWriter().close();
+    }
 }
diff --git 
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptor.java
 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptor.java
new file mode 100644
index 000000000..76afb21da
--- /dev/null
+++ 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptor.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.  For additional information regarding
+ * copyright in this work, please see the NOTICE file in the top level
+ * directory of this distribution.
+ */
+
+package org.apache.roller.weblogger.ui.struts2.util;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.roller.weblogger.ui.core.filters.SaltValidator;
+import org.apache.struts2.StrutsStatics;
+import org.apache.struts2.dispatcher.multipart.MultiPartRequestWrapper;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
+
+/**
+ * Validates salts after Struts has wrapped a multipart form request.
+ */
+public class ValidateSaltInterceptor extends AbstractInterceptor implements 
StrutsStatics {
+
+    private static final long serialVersionUID = 2446434402795510394L;
+    private static final Log log = 
LogFactory.getLog(ValidateSaltInterceptor.class);
+
+    @Override
+    public String intercept(ActionInvocation invocation) throws Exception {
+        ActionContext context = invocation.getInvocationContext();
+        HttpServletRequest request = (HttpServletRequest) 
context.get(HTTP_REQUEST);
+
+        if (SaltValidator.isMultipartFormPost(request)
+                && !Boolean.TRUE.equals(request.getAttribute(
+                        SaltValidator.VALIDATED_REQUEST_ATTRIBUTE))) {
+            if (request instanceof MultiPartRequestWrapper
+                    && ((MultiPartRequestWrapper) request).hasErrors()) {
+                return invocation.invoke();
+            }
+
+            try {
+                SaltValidator.requireSubmittedSalt(request);
+            } catch (ServletException e) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Valid salt value not found on multipart POST to 
URL : "
+                            + request.getServletPath());
+                }
+                throw e;
+            }
+            request.setAttribute(
+                    SaltValidator.VALIDATED_REQUEST_ATTRIBUTE, Boolean.TRUE);
+        }
+
+        return invocation.invoke();
+    }
+}
diff --git 
a/app/src/main/resources/org/apache/roller/weblogger/config/roller.properties 
b/app/src/main/resources/org/apache/roller/weblogger/config/roller.properties
index 8fba94217..32fbc5961 100644
--- 
a/app/src/main/resources/org/apache/roller/weblogger/config/roller.properties
+++ 
b/app/src/main/resources/org/apache/roller/weblogger/config/roller.properties
@@ -382,9 +382,6 @@ schemeenforcement.https.urls=/roller_j_security_check,\
 # Ignored extensions otherwise we get SSL mixed content issues
 schemeenforcement.https.ignored=css,gif,png,js
 
-# Ignored urls for salt.  These are for multipart/form-data submissions as we 
do not get any parameters
-salt.ignored.urls=mediaFileAdd!save.rol,mediaFileEdit!save.rol,bookmarksImport!save.rol
-
 #---------------------------------------------------------------------
 # LDAP authentication properties -- valid only if LDAP authentication
 # authentication.method via authentication.method setting.
diff --git a/app/src/main/resources/struts.xml 
b/app/src/main/resources/struts.xml
index e3bab427c..c362818a7 100644
--- a/app/src/main/resources/struts.xml
+++ b/app/src/main/resources/struts.xml
@@ -37,6 +37,8 @@
                          
class="org.apache.roller.weblogger.ui.struts2.util.UISecurityInterceptor" />
             <interceptor name="UIActionPrepareInterceptor" 
                          
class="org.apache.roller.weblogger.ui.struts2.util.UIActionPrepareInterceptor" 
/>
+            <interceptor name="ValidateSaltInterceptor"
+                         
class="org.apache.roller.weblogger.ui.struts2.util.ValidateSaltInterceptor" />
                          
             <!-- Define a custom interceptor stack for Roller so that we can 
                  add in our own custom interceptors.  We basically copy the 
@@ -45,6 +47,7 @@
                  default stack -->
             <interceptor-stack name="rollerStack">
                 <interceptor-ref name="exception"/>
+                <interceptor-ref name="ValidateSaltInterceptor"/>
                 <!-- <interceptor-ref name="alias"/> -->
                 <interceptor-ref name="servletConfig"/>
                 <!-- <interceptor-ref name="prepare"/> -->
diff --git a/app/src/main/webapp/WEB-INF/jsps/editor/Comments.jsp 
b/app/src/main/webapp/WEB-INF/jsps/editor/Comments.jsp
index f13a8d59e..78c3f7d71 100644
--- a/app/src/main/webapp/WEB-INF/jsps/editor/Comments.jsp
+++ b/app/src/main/webapp/WEB-INF/jsps/editor/Comments.jsp
@@ -434,9 +434,9 @@
             dataType: "text",
             processData: "false",
             contentType: "text/plain",
-            success: function (rdata) {
-                if (status != "success") {
-                    var cdata = eval("(" + rdata + ")");
+            success: function (rdata, status) {
+                var cdata = updateCommentSalt(rdata);
+                if (status === "success" && cdata && cdata.content !== 
undefined) {
                     $("#editlink-" + id).show();
                     $("#savelink-" + id).hide();
                     $("#cancellink-" + id).hide();
@@ -444,10 +444,26 @@
                 } else {
                     alert('<s:text name="commentManagement.saveError" />');
                 }
+            },
+            error: function (xhr) {
+                updateCommentSalt(xhr.responseText);
+                alert('<s:text name="commentManagement.saveError" />');
             }
         });
     }
 
+    function updateCommentSalt(rdata) {
+        try {
+            var cdata = JSON.parse(rdata);
+            if (cdata.salt) {
+                $("#comments_salt").val(cdata.salt);
+            }
+            return cdata;
+        } catch (error) {
+            return null;
+        }
+    }
+
     function editCommentCancel(id) {
         $("#editlink-" + id).show();
         $("#savelink-" + id).hide();
diff --git a/app/src/main/webapp/WEB-INF/web.xml 
b/app/src/main/webapp/WEB-INF/web.xml
index 0418832da..746d20d26 100644
--- a/app/src/main/webapp/WEB-INF/web.xml
+++ b/app/src/main/webapp/WEB-INF/web.xml
@@ -142,15 +142,15 @@
     </filter-mapping>
 
        <filter-mapping>
-               <filter-name>LoadSaltFilter</filter-name>
+               <filter-name>ValidateSaltFilter</filter-name>
                <url-pattern>/roller-ui/*</url-pattern>
-        <dispatcher>REQUEST</dispatcher>
-        <dispatcher>FORWARD</dispatcher>
        </filter-mapping>
 
        <filter-mapping>
-               <filter-name>ValidateSaltFilter</filter-name>
+               <filter-name>LoadSaltFilter</filter-name>
                <url-pattern>/roller-ui/*</url-pattern>
+        <dispatcher>REQUEST</dispatcher>
+        <dispatcher>FORWARD</dispatcher>
        </filter-mapping>
 
     <!-- Request mapping, this is what allows the urls to work -->
diff --git 
a/app/src/test/java/org/apache/roller/weblogger/ui/core/filters/SaltConfigurationTest.java
 
b/app/src/test/java/org/apache/roller/weblogger/ui/core/filters/SaltConfigurationTest.java
new file mode 100644
index 000000000..8f28874bb
--- /dev/null
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/core/filters/SaltConfigurationTest.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.  For additional information regarding
+ * copyright in this work, please see the NOTICE file in the top level
+ * directory of this distribution.
+ */
+
+package org.apache.roller.weblogger.ui.core.filters;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class SaltConfigurationTest {
+
+    @Test
+    public void testSubmittedSaltIsValidatedBeforeResponseSaltIsLoaded() 
throws Exception {
+        Path projectDirectory = Path.of(
+                System.getProperty("project.build.directory")).getParent();
+        String webXml = Files.readString(projectDirectory.resolve(
+                "src/main/webapp/WEB-INF/web.xml"));
+
+        int validateMapping = filterMappingPosition(webXml, 
"ValidateSaltFilter");
+        int loadMapping = filterMappingPosition(webXml, "LoadSaltFilter");
+
+        assertTrue(validateMapping >= 0, "ValidateSaltFilter mapping is 
missing");
+        assertTrue(loadMapping >= 0, "LoadSaltFilter mapping is missing");
+        assertTrue(validateMapping < loadMapping,
+                "ValidateSaltFilter must run before LoadSaltFilter");
+    }
+
+    @Test
+    public void 
testMultipartSaltValidationImmediatelyFollowsExceptionInterceptor() throws 
Exception {
+        String strutsXml = readResource("/struts.xml");
+
+        Pattern adjacentInterceptors = Pattern.compile(
+                "<interceptor-ref name=\"exception\"/>\\s*"
+                + "<interceptor-ref name=\"ValidateSaltInterceptor\"/>");
+
+        assertTrue(adjacentInterceptors.matcher(strutsXml).find(),
+                "ValidateSaltInterceptor must immediately follow the exception 
interceptor");
+    }
+
+    private int filterMappingPosition(String webXml, String filterName) {
+        Pattern pattern = Pattern.compile("<filter-mapping>\\s*<filter-name>"
+                + Pattern.quote(filterName) + "</filter-name>");
+        Matcher matcher = pattern.matcher(webXml);
+        return matcher.find() ? matcher.start() : -1;
+    }
+
+    private String readResource(String path) throws IOException {
+        try (java.io.InputStream stream =
+                     SaltConfigurationTest.class.getResourceAsStream(path)) {
+            if (stream == null) {
+                throw new IOException("Test resource not found: " + path);
+            }
+            return new String(stream.readAllBytes(), StandardCharsets.UTF_8);
+        }
+    }
+}
diff --git 
a/app/src/test/java/org/apache/roller/weblogger/ui/core/filters/ValidateSaltFilterTest.java
 
b/app/src/test/java/org/apache/roller/weblogger/ui/core/filters/ValidateSaltFilterTest.java
index ab866d080..5f0715bee 100644
--- 
a/app/src/test/java/org/apache/roller/weblogger/ui/core/filters/ValidateSaltFilterTest.java
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/core/filters/ValidateSaltFilterTest.java
@@ -1,6 +1,5 @@
 package org.apache.roller.weblogger.ui.core.filters;
 
-import org.apache.roller.weblogger.config.WebloggerConfig;
 import org.apache.roller.weblogger.pojos.User;
 import org.apache.roller.weblogger.ui.core.RollerSession;
 import org.apache.roller.weblogger.ui.rendering.util.cache.SaltCache;
@@ -11,7 +10,6 @@ import org.mockito.MockedStatic;
 import org.mockito.MockitoAnnotations;
 
 import javax.servlet.FilterChain;
-import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
@@ -47,8 +45,6 @@ public class ValidateSaltFilterTest {
     @Test
     public void testDoFilterWithGetMethod() throws Exception {
         when(request.getMethod()).thenReturn("GET");
-        StringBuffer requestURL = new 
StringBuffer("https://example.com/app/ignoredurl";);
-        when(request.getRequestURL()).thenReturn(requestURL);
 
         filter.doFilter(request, response, chain);
 
@@ -67,9 +63,6 @@ public class ValidateSaltFilterTest {
             when(request.getParameter("salt")).thenReturn("validSalt");
             when(saltCache.get("validSalt")).thenReturn("userId");
             when(rollerSession.getAuthenticatedUser()).thenReturn(new 
TestUser("userId"));
-            StringBuffer requestURL = new 
StringBuffer("https://example.com/app/ignoredurl";);
-            when(request.getRequestURL()).thenReturn(requestURL);
-
             filter.doFilter(request, response, chain);
 
             verify(chain).doFilter(request, response);
@@ -88,9 +81,6 @@ public class ValidateSaltFilterTest {
             when(request.getMethod()).thenReturn("POST");
             when(request.getParameter("salt")).thenReturn("invalidSalt");
             when(saltCache.get("invalidSalt")).thenReturn(null);
-            StringBuffer requestURL = new 
StringBuffer("https://example.com/app/ignoredurl";);
-            when(request.getRequestURL()).thenReturn(requestURL);
-
             assertThrows(ServletException.class, () -> {
                 filter.doFilter(request, response, chain);
             });
@@ -109,9 +99,6 @@ public class ValidateSaltFilterTest {
             when(request.getParameter("salt")).thenReturn("validSalt");
             when(saltCache.get("validSalt")).thenReturn("differentUserId");
             when(rollerSession.getAuthenticatedUser()).thenReturn(new 
TestUser("userId"));
-            StringBuffer requestURL = new 
StringBuffer("https://example.com/app/ignoredurl";);
-            when(request.getRequestURL()).thenReturn(requestURL);
-
             assertThrows(ServletException.class, () -> {
                 filter.doFilter(request, response, chain);
             });
@@ -129,9 +116,6 @@ public class ValidateSaltFilterTest {
             when(request.getMethod()).thenReturn("POST");
             when(request.getParameter("salt")).thenReturn("validSalt");
             when(saltCache.get("validSalt")).thenReturn("");
-            StringBuffer requestURL = new 
StringBuffer("https://example.com/app/ignoredurl";);
-            when(request.getRequestURL()).thenReturn(requestURL);
-
             filter.doFilter(request, response, chain);
 
             verify(saltCache, never()).remove("validSalt");
@@ -139,32 +123,81 @@ public class ValidateSaltFilterTest {
     }
 
     @Test
-    public void testDoFilterWithIgnoredURL() throws Exception {
+    public void testPostWithoutParameterRejectsRequestAttributeSalt() throws 
Exception {
         try (MockedStatic<RollerSession> mockedRollerSession = 
mockStatic(RollerSession.class);
-             MockedStatic<SaltCache> mockedSaltCache = 
mockStatic(SaltCache.class);
-             MockedStatic<WebloggerConfig> mockedWebloggerConfig = 
mockStatic(WebloggerConfig.class)) {
+             MockedStatic<SaltCache> mockedSaltCache = 
mockStatic(SaltCache.class)) {
 
             mockedRollerSession.when(() -> 
RollerSession.getRollerSession(request)).thenReturn(rollerSession);
             mockedSaltCache.when(SaltCache::getInstance).thenReturn(saltCache);
-            mockedWebloggerConfig.when(() -> 
WebloggerConfig.getProperty("salt.ignored.urls"))
-                    
.thenReturn("https://example.com/app/ignoredurl?param1=value1&m2=value2";);
 
             when(request.getMethod()).thenReturn("POST");
-            StringBuffer requestURL = new 
StringBuffer("https://example.com/app/ignoredurl";);
-            when(request.getRequestURL()).thenReturn(requestURL);
-            
when(request.getQueryString()).thenReturn("param1=value1&m2=value2");
-            when(request.getParameter("salt")).thenReturn(null);  // No salt 
provided
+            when(request.getAttribute("salt")).thenReturn("responseSalt");
+            when(request.getParameter("salt")).thenReturn(null);
+            when(rollerSession.getAuthenticatedUser()).thenReturn(new 
TestUser("userId"));
+            when(saltCache.get("responseSalt")).thenReturn("userId");
 
-            filter.init(mock(FilterConfig.class));
-            filter.doFilter(request, response, chain);
+            assertThrows(ServletException.class,
+                    () -> filter.doFilter(request, response, chain));
 
-            verify(chain).doFilter(request, response);
+            verify(chain, never()).doFilter(request, response);
             verify(saltCache, never()).get(anyString());
             verify(saltCache, never()).remove(anyString());
         }
     }
 
+    @Test
+    public void testSubmittedSaltCanOnlyBeUsedOnce() throws Exception {
+        try (MockedStatic<RollerSession> mockedRollerSession = 
mockStatic(RollerSession.class);
+             MockedStatic<SaltCache> mockedSaltCache = 
mockStatic(SaltCache.class)) {
+
+            mockedRollerSession.when(() -> 
RollerSession.getRollerSession(request)).thenReturn(rollerSession);
+            mockedSaltCache.when(SaltCache::getInstance).thenReturn(saltCache);
+
+            when(request.getMethod()).thenReturn("POST");
+            when(request.getParameter("salt")).thenReturn("validSalt");
+            when(rollerSession.getAuthenticatedUser()).thenReturn(new 
TestUser("userId"));
+            when(saltCache.get("validSalt")).thenReturn("userId", (String) 
null);
+
+            filter.doFilter(request, response, chain);
+            assertThrows(ServletException.class,
+                    () -> filter.doFilter(request, response, chain));
+
+            verify(chain, times(1)).doFilter(request, response);
+            verify(saltCache, times(1)).remove("validSalt");
+        }
+    }
+
+    @Test
+    public void testMultipartStrutsPostIsDeferred() throws Exception {
+        when(request.getMethod()).thenReturn("POST");
+        when(request.getContentType()).thenReturn("multipart/form-data; 
boundary=abc123");
+        
when(request.getServletPath()).thenReturn("/roller-ui/mediaFileAdd!save.rol");
+
+        filter.doFilter(request, response, chain);
+
+        verify(chain).doFilter(request, response);
+        verify(request, never()).getParameter("salt");
+    }
+
+    @Test
+    public void testMultipartNonStrutsPostIsNotDeferred() throws Exception {
+        try (MockedStatic<RollerSession> mockedRollerSession = 
mockStatic(RollerSession.class)) {
+            mockedRollerSession.when(() -> 
RollerSession.getRollerSession(request)).thenReturn(rollerSession);
+
+            when(request.getMethod()).thenReturn("POST");
+            when(request.getContentType()).thenReturn("multipart/form-data; 
boundary=abc123");
+            when(request.getServletPath()).thenReturn("/roller-ui/upload");
+            when(request.getParameter("salt")).thenReturn(null);
+
+            assertThrows(ServletException.class,
+                    () -> filter.doFilter(request, response, chain));
+
+            verify(chain, never()).doFilter(request, response);
+        }
+    }
+
     private static class TestUser extends User {
+        private static final long serialVersionUID = 1L;
         private final String id;
 
         TestUser(String id) {
diff --git 
a/app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/CommentDataServletTest.java
 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/CommentDataServletTest.java
new file mode 100644
index 000000000..9c3e87618
--- /dev/null
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/CommentDataServletTest.java
@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.  For additional information regarding
+ * copyright in this work, please see the NOTICE file in the top level
+ * directory of this distribution.
+ */
+
+package org.apache.roller.weblogger.ui.struts2.ajax;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
+
+import javax.servlet.ReadListener;
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.roller.weblogger.business.Weblogger;
+import org.apache.roller.weblogger.business.WebloggerFactory;
+import org.apache.roller.weblogger.business.WeblogEntryManager;
+import org.apache.roller.weblogger.pojos.User;
+import org.apache.roller.weblogger.pojos.Weblog;
+import org.apache.roller.weblogger.pojos.WeblogEntry;
+import org.apache.roller.weblogger.pojos.WeblogEntryComment;
+import org.apache.roller.weblogger.pojos.WeblogPermission;
+import org.apache.roller.weblogger.ui.core.RollerSession;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class CommentDataServletTest {
+
+    @Test
+    public void testRepeatedSavesReturnFreshResponseSalts() throws Exception {
+        Weblogger weblogger = mock(Weblogger.class);
+        WeblogEntryManager manager = mock(WeblogEntryManager.class);
+        WeblogEntryComment comment = mock(WeblogEntryComment.class);
+        WeblogEntry entry = mock(WeblogEntry.class);
+        Weblog weblog = mock(Weblog.class);
+        RollerSession session = mock(RollerSession.class);
+        User user = mock(User.class);
+
+        when(weblogger.getWeblogEntryManager()).thenReturn(manager);
+        when(manager.getComment("comment-id")).thenReturn(comment);
+        when(comment.getWeblogEntry()).thenReturn(entry);
+        when(entry.getWebsite()).thenReturn(weblog);
+        when(session.getAuthenticatedUser()).thenReturn(user);
+        when(weblog.hasUserPermission(user, 
WeblogPermission.POST)).thenReturn(true);
+        when(comment.getId()).thenReturn("comment-id");
+        when(comment.getContent()).thenReturn("updated");
+
+        try (MockedStatic<WebloggerFactory> factory = 
mockStatic(WebloggerFactory.class);
+             MockedStatic<RollerSession> sessions = 
mockStatic(RollerSession.class)) {
+            factory.when(WebloggerFactory::getWeblogger).thenReturn(weblogger);
+
+            HttpServletRequest firstRequest = 
saveRequest("first-response-salt");
+            HttpServletResponse firstResponse = 
mock(HttpServletResponse.class);
+            StringWriter firstBody = responseBody(firstResponse);
+            sessions.when(() -> 
RollerSession.getRollerSession(firstRequest)).thenReturn(session);
+
+            new CommentDataServlet().doPost(firstRequest, firstResponse);
+
+            HttpServletRequest secondRequest = 
saveRequest("second-response-salt");
+            HttpServletResponse secondResponse = 
mock(HttpServletResponse.class);
+            StringWriter secondBody = responseBody(secondResponse);
+            sessions.when(() -> 
RollerSession.getRollerSession(secondRequest)).thenReturn(session);
+
+            new CommentDataServlet().doPost(secondRequest, secondResponse);
+
+            assertTrue(firstBody.toString().contains(
+                    "\"salt\":\"first-response-salt\""));
+            assertTrue(secondBody.toString().contains(
+                    "\"salt\":\"second-response-salt\""));
+            verify(manager, times(2)).saveComment(comment);
+        }
+    }
+
+    @Test
+    public void testHandledErrorReturnsFreshResponseSalt() throws Exception {
+        Weblogger weblogger = mock(Weblogger.class);
+        WeblogEntryManager manager = mock(WeblogEntryManager.class);
+        when(weblogger.getWeblogEntryManager()).thenReturn(manager);
+        when(manager.getComment("missing-id")).thenReturn(null);
+
+        HttpServletRequest request = mock(HttpServletRequest.class);
+        when(request.getParameter("id")).thenReturn("missing-id");
+        when(request.getAttribute("salt")).thenReturn("replacement-salt");
+        HttpServletResponse response = mock(HttpServletResponse.class);
+        PrintWriter writer = mock(PrintWriter.class);
+        when(response.getWriter()).thenReturn(writer);
+
+        try (MockedStatic<WebloggerFactory> factory = 
mockStatic(WebloggerFactory.class)) {
+            factory.when(WebloggerFactory::getWeblogger).thenReturn(weblogger);
+
+            new CommentDataServlet().doPost(request, response);
+        }
+
+        verify(response).setStatus(HttpServletResponse.SC_NOT_FOUND);
+        verify(writer).print("{\"salt\":\"replacement-salt\"}");
+    }
+
+    private HttpServletRequest saveRequest(String responseSalt) throws 
Exception {
+        HttpServletRequest request = mock(HttpServletRequest.class);
+        when(request.getParameter("id")).thenReturn("comment-id");
+        when(request.getAttribute("salt")).thenReturn(responseSalt);
+        when(request.getInputStream()).thenReturn(
+                new ByteArrayServletInputStream("updated"));
+        return request;
+    }
+
+    private StringWriter responseBody(HttpServletResponse response) throws 
Exception {
+        StringWriter body = new StringWriter();
+        when(response.getWriter()).thenReturn(new PrintWriter(body));
+        return body;
+    }
+
+    private static class ByteArrayServletInputStream extends 
ServletInputStream {
+        private final ByteArrayInputStream input;
+
+        ByteArrayServletInputStream(String value) {
+            input = new ByteArrayInputStream(
+                    value.getBytes(StandardCharsets.UTF_8));
+        }
+
+        @Override
+        public boolean isFinished() {
+            return input.available() == 0;
+        }
+
+        @Override
+        public boolean isReady() {
+            return true;
+        }
+
+        @Override
+        public void setReadListener(ReadListener readListener) {
+        }
+
+        @Override
+        public int read() throws IOException {
+            return input.read();
+        }
+    }
+}
diff --git 
a/app/src/test/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptorTest.java
 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptorTest.java
new file mode 100644
index 000000000..1aea1b664
--- /dev/null
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptorTest.java
@@ -0,0 +1,219 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.  For additional information regarding
+ * copyright in this work, please see the NOTICE file in the top level
+ * directory of this distribution.
+ */
+
+package org.apache.roller.weblogger.ui.struts2.util;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.roller.weblogger.pojos.User;
+import org.apache.roller.weblogger.ui.core.RollerSession;
+import org.apache.roller.weblogger.ui.core.filters.SaltValidator;
+import org.apache.roller.weblogger.ui.rendering.util.cache.SaltCache;
+import org.apache.struts2.StrutsStatics;
+import org.apache.struts2.dispatcher.multipart.MultiPartRequestWrapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.MockitoAnnotations;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
+
+public class ValidateSaltInterceptorTest {
+
+    private ValidateSaltInterceptor interceptor;
+
+    @Mock
+    private ActionInvocation invocation;
+
+    @Mock
+    private ActionContext context;
+
+    @Mock
+    private HttpServletRequest request;
+
+    @Mock
+    private MultiPartRequestWrapper multipartRequest;
+
+    @Mock
+    private RollerSession rollerSession;
+
+    @Mock
+    private SaltCache saltCache;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.openMocks(this);
+        interceptor = new ValidateSaltInterceptor();
+        when(invocation.getInvocationContext()).thenReturn(context);
+        when(context.get(StrutsStatics.HTTP_REQUEST)).thenReturn(request);
+    }
+
+    @Test
+    public void testValidMultipartSaltIsConsumed() throws Exception {
+        try (MockedStatic<RollerSession> mockedRollerSession = 
mockStatic(RollerSession.class);
+             MockedStatic<SaltCache> mockedSaltCache = 
mockStatic(SaltCache.class)) {
+            mockedRollerSession.when(() -> 
RollerSession.getRollerSession(request)).thenReturn(rollerSession);
+            mockedSaltCache.when(SaltCache::getInstance).thenReturn(saltCache);
+
+            configureMultipartPost("/roller-ui/mediaFileAdd!save.rol");
+            when(request.getParameter("salt")).thenReturn("validSalt");
+            when(rollerSession.getAuthenticatedUser()).thenReturn(new 
TestUser("userId"));
+            when(saltCache.get("validSalt")).thenReturn("userId");
+            when(invocation.invoke()).thenReturn("success");
+
+            assertEquals("success", interceptor.intercept(invocation));
+
+            verify(saltCache).remove("validSalt");
+            verify(request).setAttribute(
+                    SaltValidator.VALIDATED_REQUEST_ATTRIBUTE, Boolean.TRUE);
+            verify(invocation).invoke();
+        }
+    }
+
+    @Test
+    public void testChainedMultipartRequestIsValidatedOnlyOnce() throws 
Exception {
+        try (MockedStatic<RollerSession> mockedRollerSession = 
mockStatic(RollerSession.class);
+             MockedStatic<SaltCache> mockedSaltCache = 
mockStatic(SaltCache.class)) {
+            mockedRollerSession.when(() -> 
RollerSession.getRollerSession(request)).thenReturn(rollerSession);
+            mockedSaltCache.when(SaltCache::getInstance).thenReturn(saltCache);
+
+            configureMultipartPost("/roller-ui/bookmarksImport!save.rol");
+            when(request.getParameter("salt")).thenReturn("validSalt");
+            when(rollerSession.getAuthenticatedUser()).thenReturn(new 
TestUser("userId"));
+            when(saltCache.get("validSalt")).thenReturn("userId");
+            
when(request.getAttribute(SaltValidator.VALIDATED_REQUEST_ATTRIBUTE))
+                    .thenReturn(null, Boolean.TRUE);
+            when(invocation.invoke()).thenReturn("success");
+
+            assertEquals("success", interceptor.intercept(invocation));
+            assertEquals("success", interceptor.intercept(invocation));
+
+            verify(saltCache).get("validSalt");
+            verify(saltCache).remove("validSalt");
+            verify(invocation, times(2)).invoke();
+        }
+    }
+
+    @Test
+    public void testMultipartParsingErrorsReachUploadHandling() throws 
Exception {
+        
when(context.get(StrutsStatics.HTTP_REQUEST)).thenReturn(multipartRequest);
+        when(multipartRequest.getMethod()).thenReturn("POST");
+        when(multipartRequest.getContentType()).thenReturn(
+                "multipart/form-data; boundary=abc123");
+        when(multipartRequest.hasErrors()).thenReturn(true);
+        when(invocation.invoke()).thenReturn("input");
+
+        assertEquals("input", interceptor.intercept(invocation));
+
+        verify(multipartRequest, never()).getParameter("salt");
+        verify(invocation).invoke();
+    }
+
+    @Test
+    public void 
testMultipartPostWithoutSaltIsRejectedEvenWithResponseSaltAttribute() throws 
Exception {
+        try (MockedStatic<RollerSession> mockedRollerSession = 
mockStatic(RollerSession.class)) {
+            mockedRollerSession.when(() -> 
RollerSession.getRollerSession(request)).thenReturn(rollerSession);
+
+            configureMultipartPost("/roller-ui/bookmarksImport!save.rol");
+            when(request.getParameter("salt")).thenReturn(null);
+            when(request.getAttribute("salt")).thenReturn("responseSalt");
+
+            assertThrows(ServletException.class, () -> 
interceptor.intercept(invocation));
+
+            verify(invocation, never()).invoke();
+        }
+    }
+
+    @Test
+    public void testInvalidMultipartSaltIsRejectedForAnyRollerAction() throws 
Exception {
+        try (MockedStatic<RollerSession> mockedRollerSession = 
mockStatic(RollerSession.class);
+             MockedStatic<SaltCache> mockedSaltCache = 
mockStatic(SaltCache.class)) {
+            mockedRollerSession.when(() -> 
RollerSession.getRollerSession(request)).thenReturn(rollerSession);
+            mockedSaltCache.when(SaltCache::getInstance).thenReturn(saltCache);
+
+            configureMultipartPost("/roller-ui/arbitrary!save.rol");
+            when(request.getParameter("salt")).thenReturn("invalidSalt");
+            when(saltCache.get("invalidSalt")).thenReturn(null);
+
+            assertThrows(ServletException.class, () -> 
interceptor.intercept(invocation));
+
+            verify(invocation, never()).invoke();
+            verify(saltCache, never()).remove(anyString());
+        }
+    }
+
+    @Test
+    public void testMultipartSaltCannotBeReplayed() throws Exception {
+        try (MockedStatic<RollerSession> mockedRollerSession = 
mockStatic(RollerSession.class);
+             MockedStatic<SaltCache> mockedSaltCache = 
mockStatic(SaltCache.class)) {
+            mockedRollerSession.when(() -> 
RollerSession.getRollerSession(request)).thenReturn(rollerSession);
+            mockedSaltCache.when(SaltCache::getInstance).thenReturn(saltCache);
+
+            configureMultipartPost("/roller-ui/mediaFileEdit!save.rol");
+            when(request.getParameter("salt")).thenReturn("validSalt");
+            when(rollerSession.getAuthenticatedUser()).thenReturn(new 
TestUser("userId"));
+            when(saltCache.get("validSalt")).thenReturn("userId", (String) 
null);
+
+            interceptor.intercept(invocation);
+            assertThrows(ServletException.class, () -> 
interceptor.intercept(invocation));
+
+            verify(invocation, times(1)).invoke();
+            verify(saltCache, times(1)).remove("validSalt");
+        }
+    }
+
+    @Test
+    public void testOrdinaryPostIsNotValidatedTwice() throws Exception {
+        when(request.getMethod()).thenReturn("POST");
+        
when(request.getContentType()).thenReturn("application/x-www-form-urlencoded");
+        when(invocation.invoke()).thenReturn("success");
+
+        assertEquals("success", interceptor.intercept(invocation));
+
+        verify(request, never()).getParameter("salt");
+        verify(invocation).invoke();
+    }
+
+    private void configureMultipartPost(String servletPath) {
+        when(request.getMethod()).thenReturn("POST");
+        when(request.getContentType()).thenReturn("multipart/form-data; 
boundary=abc123");
+        when(request.getServletPath()).thenReturn(servletPath);
+    }
+
+    private static class TestUser extends User {
+        private static final long serialVersionUID = 1L;
+        private final String id;
+
+        TestUser(String id) {
+            this.id = id;
+        }
+
+        @Override
+        public String getId() {
+            return id;
+        }
+    }
+}

Reply via email to