You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@grails.apache.org by ja...@apache.org on 2026/07/01 08:29:11 UTC

(grails-core) 01/01: Harden synchronizer token consumption

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

jamesfredley pushed a commit to branch fix/synchronizer-token-hardening
in repository https://gitbox.apache.org/repos/asf/grails-core.git

commit f252b430cb9c74f0705a14798df7bae3902533ed
Author: James Fredley <ja...@users.noreply.github.com>
AuthorDate: Wed Jul 1 04:25:08 2026 -0400

    Harden synchronizer token consumption
    
    Bound the per-session synchronizer token holder by URL and per-URL token count, and consume withForm tokens through a single holder-level atomic validate-and-reset operation. This prevents unbounded token growth and closes the race where concurrent submits could validate the same token before reset.
    
    Assisted-by: opencode:gpt-5.5
---
 .../main/groovy/grails/artefact/Controller.groovy  | 29 ++-----
 .../src/test/groovy/demo/TestControllerSpec.groovy |  7 ++
 .../src/test/groovy/demo/TestControllerSpec.groovy |  7 ++
 .../mvc/SynchronizerTokensHolderTests.groovy       | 95 ++++++++++++++++++++++
 .../servlet/mvc/SynchronizerTokensHolder.groovy    | 84 ++++++++++++++-----
 5 files changed, 178 insertions(+), 44 deletions(-)

diff --git a/grails-controllers/src/main/groovy/grails/artefact/Controller.groovy b/grails-controllers/src/main/groovy/grails/artefact/Controller.groovy
index 707ac284e9..2ebaf25852 100644
--- a/grails-controllers/src/main/groovy/grails/artefact/Controller.groovy
+++ b/grails-controllers/src/main/groovy/grails/artefact/Controller.groovy
@@ -286,8 +286,7 @@ trait Controller implements ResponseRenderer, ResponseRedirector, RequestForward
     @Generated
     TokenResponseHandler withForm(GrailsWebRequest webRequest, Closure callable) {
         TokenResponseHandler handler
-        if (isTokenValid(webRequest)) {
-            resetToken(webRequest)
+        if (consumeToken(webRequest)) {
             handler = new ValidResponseHandler(callable?.call())
         }
         else {
@@ -303,7 +302,7 @@ trait Controller implements ResponseRenderer, ResponseRedirector, RequestForward
      *
      * @param request The servlet request
      */
-    private synchronized boolean isTokenValid(GrailsWebRequest webRequest) {
+    private boolean consumeToken(GrailsWebRequest webRequest) {
         final request = webRequest.getCurrentRequest()
         SynchronizerTokensHolder tokensHolderInSession = (SynchronizerTokensHolder) request.getSession(false)?.getAttribute(SynchronizerTokensHolder.HOLDER)
         if (!tokensHolderInSession) return false
@@ -314,27 +313,11 @@ trait Controller implements ResponseRenderer, ResponseRedirector, RequestForward
         String urlInRequest = webRequest.params[SynchronizerTokensHolder.TOKEN_URI]
         if (!urlInRequest) return false
 
-        try {
-            return tokensHolderInSession.isValid(urlInRequest, tokenInRequest)
-        }
-        catch (IllegalArgumentException) {
-            return false
-        }
-    }
-
-    /**
-     * Resets the token in the request
-     */
-    private synchronized resetToken(GrailsWebRequest webRequest) {
-        final request = webRequest.getCurrentRequest()
-        SynchronizerTokensHolder tokensHolderInSession = (SynchronizerTokensHolder) request.getSession(false)?.getAttribute(SynchronizerTokensHolder.HOLDER)
-        String urlInRequest = webRequest.params[SynchronizerTokensHolder.TOKEN_URI]
-        String tokenInRequest = webRequest.params[SynchronizerTokensHolder.TOKEN_KEY]
-
-        if (urlInRequest && tokenInRequest) {
-            tokensHolderInSession.resetToken(urlInRequest, tokenInRequest)
+        boolean valid = tokensHolderInSession.isValidAndResetToken(urlInRequest, tokenInRequest)
+        if (tokensHolderInSession.isEmpty()) {
+            request.getSession(false)?.removeAttribute(SynchronizerTokensHolder.HOLDER)
         }
-        if (tokensHolderInSession.isEmpty()) request.getSession(false)?.removeAttribute(SynchronizerTokensHolder.HOLDER)
+        return valid
     }
 
     @Generated
diff --git a/grails-test-examples/demo33/src/test/groovy/demo/TestControllerSpec.groovy b/grails-test-examples/demo33/src/test/groovy/demo/TestControllerSpec.groovy
index c0e7cb3c3a..beefc6838a 100644
--- a/grails-test-examples/demo33/src/test/groovy/demo/TestControllerSpec.groovy
+++ b/grails-test-examples/demo33/src/test/groovy/demo/TestControllerSpec.groovy
@@ -157,6 +157,13 @@ class TestControllerSpec extends Specification implements ControllerUnitTest<Tes
 
         then:
         "Good" == response.text
+
+        when:
+        response.reset()
+        controller.renderWithForm()
+
+        then:
+        "Bad" == response.text
     }
 
     void 'test file upload'() {
diff --git a/grails-test-examples/hibernate7/demo33/src/test/groovy/demo/TestControllerSpec.groovy b/grails-test-examples/hibernate7/demo33/src/test/groovy/demo/TestControllerSpec.groovy
index c0e7cb3c3a..beefc6838a 100644
--- a/grails-test-examples/hibernate7/demo33/src/test/groovy/demo/TestControllerSpec.groovy
+++ b/grails-test-examples/hibernate7/demo33/src/test/groovy/demo/TestControllerSpec.groovy
@@ -157,6 +157,13 @@ class TestControllerSpec extends Specification implements ControllerUnitTest<Tes
 
         then:
         "Good" == response.text
+
+        when:
+        response.reset()
+        controller.renderWithForm()
+
+        then:
+        "Bad" == response.text
     }
 
     void 'test file upload'() {
diff --git a/grails-test-suite-web/src/test/groovy/org/grails/web/servlet/mvc/SynchronizerTokensHolderTests.groovy b/grails-test-suite-web/src/test/groovy/org/grails/web/servlet/mvc/SynchronizerTokensHolderTests.groovy
index 09c30e7669..4f0f95101f 100644
--- a/grails-test-suite-web/src/test/groovy/org/grails/web/servlet/mvc/SynchronizerTokensHolderTests.groovy
+++ b/grails-test-suite-web/src/test/groovy/org/grails/web/servlet/mvc/SynchronizerTokensHolderTests.groovy
@@ -18,6 +18,11 @@
  */
 package org.grails.web.servlet.mvc
 
+import java.util.concurrent.Callable
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.Future
+
 import org.junit.jupiter.api.Test
 
 import static org.junit.jupiter.api.Assertions.*
@@ -73,6 +78,35 @@ class SynchronizerTokensHolderTests {
         assertEquals 1, holder.currentTokens[url2].size()
     }
 
+    @Test
+    void testGeneratedTokensAreBoundedByUrlCount() {
+        SynchronizerTokensHolder holder = new SynchronizerTokensHolder()
+
+        String firstUrl = 'url0'
+        String firstToken = holder.generateToken(firstUrl)
+        (1..SynchronizerTokensHolder.DEFAULT_MAX_TOKEN_URLS).each { Integer index ->
+            holder.generateToken("url${index}".toString())
+        }
+
+        assertEquals SynchronizerTokensHolder.DEFAULT_MAX_TOKEN_URLS, holder.currentTokens.size()
+        assertFalse holder.isValid(firstUrl, firstToken)
+    }
+
+    @Test
+    void testGeneratedTokensAreBoundedPerUrl() {
+        SynchronizerTokensHolder holder = new SynchronizerTokensHolder()
+        String url = 'url1'
+        String firstToken = holder.generateToken(url)
+        String lastToken = null
+        (1..SynchronizerTokensHolder.DEFAULT_MAX_TOKENS_PER_URL).each {
+            lastToken = holder.generateToken(url)
+        }
+
+        assertEquals SynchronizerTokensHolder.DEFAULT_MAX_TOKENS_PER_URL, holder.currentTokens[url].size()
+        assertFalse holder.isValid(url, firstToken)
+        assertTrue holder.isValid(url, lastToken)
+    }
+
     @Test
     void testIsValid() {
         SynchronizerTokensHolder holder = new SynchronizerTokensHolder()
@@ -85,6 +119,67 @@ class SynchronizerTokensHolderTests {
         assertFalse holder.isValid(url, token + '!')
     }
 
+    @Test
+    void testValidTokenCanOnlyBeConsumedOnce() {
+        SynchronizerTokensHolder holder = new SynchronizerTokensHolder()
+        String url = 'url1'
+        String token = holder.generateToken(url)
+
+        assertTrue holder.isValidAndResetToken(url, token)
+        assertFalse holder.isValidAndResetToken(url, token)
+        assertTrue holder.empty
+    }
+
+    @Test
+    void testInvalidTokensAreNotConsumed() {
+        SynchronizerTokensHolder holder = new SynchronizerTokensHolder()
+        String url = 'url1'
+        String token = holder.generateToken(url)
+
+        assertFalse holder.isValidAndResetToken(url, null)
+        assertFalse holder.isValidAndResetToken(url, '')
+        assertFalse holder.isValidAndResetToken(url, token + '!')
+        assertTrue holder.isValidAndResetToken(url, token)
+    }
+
+    @Test
+    void testConsumingOneTokenKeepsSiblingTokensForSameUrl() {
+        SynchronizerTokensHolder holder = new SynchronizerTokensHolder()
+        String url = 'url1'
+        String token1 = holder.generateToken(url)
+        String token2 = holder.generateToken(url)
+
+        assertTrue holder.isValidAndResetToken(url, token1)
+        assertFalse holder.isValidAndResetToken(url, token1)
+        assertTrue holder.isValidAndResetToken(url, token2)
+        assertTrue holder.empty
+    }
+
+    @Test
+    void testConcurrentTokenConsumeAllowsOneSuccess() {
+        SynchronizerTokensHolder holder = new SynchronizerTokensHolder()
+        String url = 'url1'
+        String token = holder.generateToken(url)
+        CountDownLatch start = new CountDownLatch(1)
+        def executor = Executors.newFixedThreadPool(2)
+
+        try {
+            List<Future<Boolean>> results = (1..2).collect {
+                executor.submit({ ->
+                    start.await()
+                    holder.isValidAndResetToken(url, token)
+                } as Callable<Boolean>)
+            }
+            start.countDown()
+
+            assertEquals 1, results.count { Future<Boolean> result -> result.get() }
+            assertTrue holder.empty
+        }
+        finally {
+            executor.shutdownNow()
+        }
+    }
+
     @Test
     void testResetTokens() {
         SynchronizerTokensHolder holder = new SynchronizerTokensHolder()
diff --git a/grails-web-mvc/src/main/groovy/org/grails/web/servlet/mvc/SynchronizerTokensHolder.groovy b/grails-web-mvc/src/main/groovy/org/grails/web/servlet/mvc/SynchronizerTokensHolder.groovy
index 17dc7321aa..ebd8f6c909 100644
--- a/grails-web-mvc/src/main/groovy/org/grails/web/servlet/mvc/SynchronizerTokensHolder.groovy
+++ b/grails-web-mvc/src/main/groovy/org/grails/web/servlet/mvc/SynchronizerTokensHolder.groovy
@@ -18,8 +18,6 @@
  */
 package org.grails.web.servlet.mvc
 
-import java.util.concurrent.CopyOnWriteArraySet
-
 import jakarta.servlet.http.HttpSession
 
 /**
@@ -35,53 +33,97 @@ class SynchronizerTokensHolder implements Serializable {
     public static final String HOLDER = 'SYNCHRONIZER_TOKENS_HOLDER'
     public static final String TOKEN_KEY = 'SYNCHRONIZER_TOKEN'
     public static final String TOKEN_URI = 'SYNCHRONIZER_URI'
+    public static final int DEFAULT_MAX_TOKEN_URLS = 100
+    public static final int DEFAULT_MAX_TOKENS_PER_URL = 100
 
-    Map<String, Set<UUID>> currentTokens = [:]
+    Map<String, Set<UUID>> currentTokens = new LinkedHashMap<String, Set<UUID>>()
 
-    boolean isValid(String url, String token) {
-        try {
-            getTokens(url).contains(UUID.fromString(token))
-        }
-        catch (IllegalArgumentException e) {
-            false
-        }
+    synchronized boolean isValid(String url, String token) {
+        UUID uuid = parseToken(token)
+        uuid != null && getExistingTokens(url)?.contains(uuid)
     }
 
-    String generateToken(String url) {
+    synchronized String generateToken(String url) {
         final UUID uuid = UUID.randomUUID()
-        getTokens(url).add(uuid)
+        Set<UUID> tokens = getTokens(url)
+        tokens.add(uuid)
+        removeEldestTokenIfNecessary(tokens)
+        removeEldestTokenUrlIfNecessary()
         return uuid
     }
 
-    void resetToken(String url) {
+    synchronized void resetToken(String url) {
         currentTokens.remove(url)
     }
 
-    void resetToken(String url, String token) {
+    synchronized void resetToken(String url, String token) {
         if (url && token) {
-            final Set set = getTokens(url)
-            try {
-                set.remove(UUID.fromString(token))
+            final Set<UUID> set = getExistingTokens(url)
+            UUID uuid = parseToken(token)
+            if (uuid != null) {
+                set?.remove(uuid)
             }
-            catch (IllegalArgumentException ignored) {}
-            if (set.isEmpty()) {
+            if (set?.isEmpty()) {
                 currentTokens.remove(url)
             }
         }
     }
 
-    boolean isEmpty() {
+    synchronized boolean isValidAndResetToken(String url, String token) {
+        UUID uuid = parseToken(token)
+        if (uuid == null) {
+            return false
+        }
+
+        final Set<UUID> set = getExistingTokens(url)
+        boolean valid = set != null && set.remove(uuid)
+        if (set?.isEmpty()) {
+            currentTokens.remove(url)
+        }
+        valid
+    }
+
+    synchronized boolean isEmpty() {
         return currentTokens.isEmpty() || currentTokens.every { String url, Set<UUID> uuids -> uuids.isEmpty() }
     }
 
     protected Set<UUID> getTokens(String url) {
         if (!currentTokens.containsKey(url)) {
-            currentTokens[url] = new CopyOnWriteArraySet<UUID>()
+            currentTokens[url] = new LinkedHashSet<UUID>()
         }
 
         currentTokens[url]
     }
 
+    private Set<UUID> getExistingTokens(String url) {
+        url ? currentTokens[url] : null
+    }
+
+    private UUID parseToken(String token) {
+        if (!token) {
+            return null
+        }
+
+        try {
+            UUID.fromString(token)
+        }
+        catch (IllegalArgumentException ignored) {
+            null
+        }
+    }
+
+    private void removeEldestTokenUrlIfNecessary() {
+        if (currentTokens.size() > DEFAULT_MAX_TOKEN_URLS) {
+            currentTokens.remove(currentTokens.keySet().iterator().next())
+        }
+    }
+
+    private void removeEldestTokenIfNecessary(Set<UUID> tokens) {
+        if (tokens.size() > DEFAULT_MAX_TOKENS_PER_URL) {
+            tokens.remove(tokens.iterator().next())
+        }
+    }
+
     static SynchronizerTokensHolder store(HttpSession session) {
         SynchronizerTokensHolder tokensHolder = session.getAttribute(HOLDER)
         if (!tokensHolder) {