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

gnodet pushed a commit to branch maven-3.10.x
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/maven-3.10.x by this push:
     new deaa92f0df fix: protect cached VersionRange restriction lists from 
mutation (#13999)
deaa92f0df is described below

commit deaa92f0df72e5bf64472b0e261fcf201f995443
Author: Amar Ghugare <[email protected]>
AuthorDate: Mon Nov 16 20:45:35 2026 +0530

    fix: protect cached VersionRange restriction lists from mutation (#13999)
    
    - `VersionRange` caches and returns shared instances from 
`createFromVersionSpec()` and `createFromVersion()`, but `getRestrictions()` 
exposed the mutable backing list; callers that cleared or mutated it corrupted 
subsequent range checks for every other caller using the same cached 
specification
    - Move the `Collections.unmodifiableList()` wrap into the private 
constructor so every code path (direct construction, `cloneOf()`, `restrict()`) 
produces an immutable restriction list from the start; remove the now-redundant 
wrapping in `restrict()`
    - Document `getRestrictions()` to state that the returned list is 
unmodifiable and non-null
    - Add parameterized tests verifying that cached, cloned, intersected, and 
version-only ranges all throw `UnsupportedOperationException` on mutation 
attempts and that the cache remains consistent after attempted mutation
    - Backported to `maven-3.10.x` (#13997) and `maven-3.9.x` (#13998)
---
 .../maven/artifact/versioning/VersionRange.java    | 12 ++++-
 .../artifact/versioning/VersionRangeTest.java      | 62 ++++++++++++++++++++++
 2 files changed, 72 insertions(+), 2 deletions(-)

diff --git 
a/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
 
b/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
index 5dcdc0fff4..21ff5dc3a0 100644
--- 
a/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
+++ 
b/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
@@ -46,13 +46,21 @@ public class VersionRange {
 
     private VersionRange(ArtifactVersion recommendedVersion, List<Restriction> 
restrictions) {
         this.recommendedVersion = recommendedVersion;
-        this.restrictions = restrictions;
+        this.restrictions = Collections.unmodifiableList(restrictions);
     }
 
     public ArtifactVersion getRecommendedVersion() {
         return recommendedVersion;
     }
 
+    /**
+     * Returns the intervals used to match versions against this range.
+     *
+     * <p>If this list is empty, {@link #containsVersion(ArtifactVersion)} 
returns {@code false}.
+     * A recommended version may still be available from {@link 
#getRecommendedVersion()}.</p>
+     *
+     * @return an unmodifiable, non-null list of version restrictions
+     */
     public List<Restriction> getRestrictions() {
         return restrictions;
     }
@@ -251,7 +259,7 @@ public VersionRange restrict(VersionRange restriction) {
         if (r1.isEmpty() || r2.isEmpty()) {
             restrictions = Collections.emptyList();
         } else {
-            restrictions = Collections.unmodifiableList(intersection(r1, r2));
+            restrictions = intersection(r1, r2);
         }
 
         ArtifactVersion version = null;
diff --git 
a/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
 
b/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
index 4f5c8984a6..fb893d76bb 100644
--- 
a/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
+++ 
b/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
@@ -18,6 +18,7 @@
  */
 package org.apache.maven.artifact.versioning;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import org.apache.maven.artifact.Artifact;
@@ -27,6 +28,7 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -749,4 +751,64 @@ public void testCache() throws 
InvalidVersionSpecificationException {
                 spec.equals(version),
                 "check 
!VersionRange.createFromVersionSpec(x).equals(VersionRange.createFromVersion(x))");
     }
+
+    @Test
+    public void testCachedRestrictionsAreUnmodifiable() throws 
InvalidVersionSpecificationException {
+        for (String spec : new String[] {"[1.1234,2.5678]", "[1.1234]", 
"(,1.1234],[2.5678,)", "1.1234"}) {
+            VersionRange range = VersionRange.createFromVersionSpec(spec);
+            List<Restriction> restrictions = new 
ArrayList<>(range.getRestrictions());
+            ArtifactVersion version = new DefaultArtifactVersion("1.1234");
+            assertTrue(range.containsVersion(version));
+
+            assertThrows(
+                    UnsupportedOperationException.class,
+                    () -> range.getRestrictions().clear());
+            assertThrows(
+                    UnsupportedOperationException.class,
+                    () -> range.getRestrictions().set(0, 
Restriction.EVERYTHING));
+
+            VersionRange cached = VersionRange.createFromVersionSpec(spec);
+            assertSame(range, cached);
+            assertEquals(restrictions, cached.getRestrictions());
+            assertTrue(cached.containsVersion(version));
+        }
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    public void testClonedRestrictionsAreUnmodifiable() throws 
InvalidVersionSpecificationException {
+        VersionRange range = 
VersionRange.createFromVersionSpec("[3.1234,4.5678]");
+        VersionRange clone = range.cloneOf();
+
+        assertThrows(
+                UnsupportedOperationException.class,
+                () -> clone.getRestrictions().clear());
+        assertEquals(range, clone);
+        assertTrue(clone.containsVersion(new 
DefaultArtifactVersion("3.5000")));
+        assertFalse(clone.containsVersion(new DefaultArtifactVersion("5.0")));
+    }
+
+    @Test
+    public void testIntersectedRestrictionsAreUnmodifiable() throws 
InvalidVersionSpecificationException {
+        VersionRange range = 
VersionRange.createFromVersionSpec("[3.1234,4.5678]")
+                .restrict(VersionRange.createFromVersionSpec("[3.5000,5.0]"));
+
+        assertThrows(
+                UnsupportedOperationException.class,
+                () -> range.getRestrictions().clear());
+        assertTrue(range.containsVersion(new DefaultArtifactVersion("4.0")));
+        assertFalse(range.containsVersion(new 
DefaultArtifactVersion("3.2500")));
+    }
+
+    @Test
+    public void testVersionRestrictionsAreUnmodifiable() {
+        VersionRange range = VersionRange.createFromVersion("3.1234");
+
+        assertThrows(
+                UnsupportedOperationException.class,
+                () -> range.getRestrictions().add(Restriction.EVERYTHING));
+        assertSame(range, VersionRange.createFromVersion("3.1234"));
+        assertTrue(range.getRestrictions().isEmpty());
+        assertEquals(new DefaultArtifactVersion("3.1234"), 
range.getRecommendedVersion());
+    }
 }

Reply via email to