From ad74c3afa5b84868750e144617b65be7b8921039 Mon Sep 17 00:00:00 2001 From: nikhil-mittal-165 Date: Tue, 27 Oct 2026 11:35:21 +0530 Subject: [PATCH 1/6] FIX Remediate SFGE transitive dependency vulnerabilities Removes all known-vulnerable libraries from the SFGE Java runtime classpath (osv-scanner on dist/java-lib: 84 advisories across 24 artifacts -> 0; 97 JARs -> 35). - Remove unused gremlin-driver (and the netty-all constraint). It was the sole source of Netty and AWS SDK JARs. - Move Gremlin from 4.0.0-beta.1 to stable 3.7.7. Every 4.0 beta bundles Jackson 2.15.2 inside gremlin-shaded. (3.8.2 changes traversal behavior and breaks tests.) - Exclude gremlin-shaded (only used for GraphSON/Gryo/GraphML IO, which SFGE does not use; its bundled Jackson cannot be patched via constraints). Add a minimal JsonProcessingException stand-in because TinkerGraph references the type. - Exclude commons-collections 3.x (no patched release; SFGE uses collections4). - Upgrade log4j to 2.25.5; force patched commons-configuration2, commons-beanutils and snakeyaml; declare commons-lang3 and commons-text explicitly. - Add verifyNoBannedDependencies build check and NoVulnerableBundledLibrariesTest to prevent regressions. Co-Authored-By: Claude Sonnet 5.5 --- .../gradle/libs.versions.toml | 21 ++++--- .../sfge/build.gradle.kts | 61 +++++++++++++++++-- .../jackson/core/JsonProcessingException.java | 23 +++++++ .../ops/NoVulnerableBundledLibrariesTest.java | 43 +++++++++++++ 4 files changed, 137 insertions(+), 11 deletions(-) create mode 100644 packages/code-analyzer-sfge-engine/sfge/src/main/java/org/apache/tinkerpop/shaded/jackson/core/JsonProcessingException.java create mode 100644 packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/graph/ops/NoVulnerableBundledLibrariesTest.java diff --git a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml index ab26b93f..423a8c57 100644 --- a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml +++ b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml @@ -10,11 +10,10 @@ hamcrest = "3.0" junit-jupiter = "5.13.4" commons-cli = "1.10.0" commons-collections4 = "4.5.0" -tinkergraph-gremlin = "4.0.0-beta.1" -gremlin-driver = "4.0.0-beta.1" +tinkergraph-gremlin = "3.7.7" antlr-runtime = "3.5.3" -log4j-api = "2.25.1" -log4j-core = "2.25.1" +log4j-api = "2.25.5" +log4j-core = "2.25.5" gson = "2.13.2" guava = "33.4.8-jre" jsr305 = "3.0.2" @@ -23,7 +22,12 @@ reflections = "0.10.2" asm = "9.8" mockito-core = "5.19.0" mockito-junit-jupiter = "5.19.0" -netty-all = "4.1.127.Final" +# Versions below force patched releases of dependencies that arrive transitively (via gremlin-core). See sfge/build.gradle.kts. +commons-configuration2 = "2.15.1" +commons-beanutils = "1.11.0" +commons-lang3 = "3.21.0" +commons-text = "1.15.0" +snakeyaml = "2.7" [libraries] hamcrest = { module = "org.hamcrest:hamcrest", version.ref = "hamcrest" } @@ -31,7 +35,6 @@ junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "jun commons-cli = { module = "commons-cli:commons-cli", version.ref = "commons-cli" } commons-collections4 = { module = "org.apache.commons:commons-collections4", version.ref = "commons-collections4" } tinkergraph-gremlin = { module = "org.apache.tinkerpop:tinkergraph-gremlin", version.ref = "tinkergraph-gremlin" } -gremlin-driver = { module = "org.apache.tinkerpop:gremlin-driver", version.ref = "gremlin-driver" } antlr-runtime = { module = "org.antlr:antlr-runtime", version.ref = "antlr-runtime" } log4j-api = { module = "org.apache.logging.log4j:log4j-api", version.ref = "log4j-api" } log4j-core = { module = "org.apache.logging.log4j:log4j-core", version.ref = "log4j-core" } @@ -44,4 +47,8 @@ asm = { module = "org.ow2.asm:asm", version.ref = "asm" } junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher" } mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito-core" } mockito-junit-jupiter = { module = "org.mockito:mockito-junit-jupiter", version.ref = "mockito-junit-jupiter" } -netty-all = { module = "io.netty:netty-all", version.ref = "netty-all" } +commons-configuration2 = { module = "org.apache.commons:commons-configuration2", version.ref = "commons-configuration2" } +commons-beanutils = { module = "commons-beanutils:commons-beanutils", version.ref = "commons-beanutils" } +commons-lang3 = { module = "org.apache.commons:commons-lang3", version.ref = "commons-lang3" } +commons-text = { module = "org.apache.commons:commons-text", version.ref = "commons-text" } +snakeyaml = { module = "org.yaml:snakeyaml", version.ref = "snakeyaml" } diff --git a/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts b/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts index f5d29853..a1619f18 100644 --- a/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts +++ b/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts @@ -22,8 +22,18 @@ repositories { dependencies { implementation(libs.commons.cli) implementation(libs.commons.collections4) - implementation(libs.tinkergraph.gremlin) - implementation(libs.gremlin.driver) + implementation(libs.tinkergraph.gremlin) { + // commons-collections 3.x (pulled in by commons-beanutils) has known vulnerabilities and no patched release. + // SFGE and the Gremlin graph layer do not use it, so it is removed from the classpath entirely. + exclude(group = "commons-collections", module = "commons-collections") + // gremlin-shaded bundles (relocated) copies of Jackson and Kryo that are only used for graph import/export + // (GraphSON/Gryo/GraphML). SFGE only builds and traverses an in-memory graph, and the bundled Jackson version + // contains known vulnerabilities that cannot be patched via dependency constraints, so we do not ship it. + exclude(group = "org.apache.tinkerpop", module = "gremlin-shaded") + } + // These are used directly by SFGE source (they previously arrived only transitively), so declare them explicitly. + implementation(libs.commons.lang3) + implementation(libs.commons.text) implementation(libs.antlr.runtime) implementation(libs.log4j.api) implementation(libs.log4j.core) @@ -35,9 +45,16 @@ dependencies { } implementation(libs.reflections) implementation(libs.asm) + // Force patched versions of transitive dependencies of gremlin-core (embedded in-memory graph). constraints { - implementation(libs.netty.all) { - because("Force specific version of transitive dependency") + implementation(libs.commons.configuration2) { + because("Patched version of a transitive dependency of gremlin-core") + } + implementation(libs.commons.beanutils) { + because("Patched version of a transitive dependency of gremlin-core") + } + implementation(libs.snakeyaml) { + because("Patched version of a transitive dependency of gremlin-core") } } implementation(files("lib/apex-jorje-lsp-sfge.jar")) @@ -76,6 +93,42 @@ tasks.build { dependsOn("copyDependencies") // Ensure dependencies are copied during the build process } +// Fail the build if a library that is known to carry unpatchable vulnerabilities (or that SFGE has no need for) sneaks +// back onto the runtime classpath, e.g., through a Gremlin upgrade. Everything on the runtime classpath gets shipped. +val bannedRuntimeDependencies = mapOf( + "io.netty" to "Only needed by gremlin-driver (remote Gremlin client), which SFGE does not use", + "software.amazon.awssdk" to "Only needed by gremlin-driver (remote Gremlin client), which SFGE does not use", + "org.apache.tinkerpop:gremlin-driver" to "SFGE only uses the embedded in-memory graph", + "org.apache.tinkerpop:gremlin-util" to "SFGE only uses the embedded in-memory graph", + "org.apache.tinkerpop:gremlin-shaded" to "Bundles Jackson/Kryo with known vulnerabilities that cannot be patched via constraints", + "commons-collections:commons-collections" to "3.x has known vulnerabilities and no patched release (SFGE uses commons-collections4)" +) +tasks.register("verifyNoBannedDependencies") { + group = "verification" + description = "Fails if a banned dependency is on the runtime classpath (and therefore would be shipped)." + val resolvedModules = configurations.runtimeClasspath.map { config -> + config.incoming.resolutionResult.allComponents + .mapNotNull { it.moduleVersion } + .map { "${it.group}:${it.name}:${it.version}" } + } + doLast { + val violations = resolvedModules.get().flatMap { coordinates -> + val (group, name) = coordinates.split(":") + bannedRuntimeDependencies.filter { (banned, _) -> banned == group || banned == "$group:$name" } + .map { (_, reason) -> "$coordinates -> $reason" } + } + if (violations.isNotEmpty()) { + throw GradleException("Banned dependencies found on the runtime classpath:\n " + violations.joinToString("\n ")) + } + } +} +tasks.check { + dependsOn("verifyNoBannedDependencies") +} +tasks.build { + dependsOn("verifyNoBannedDependencies") +} + // ======== TEST RELATED TASKS ========================================================================================= jacoco { diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/org/apache/tinkerpop/shaded/jackson/core/JsonProcessingException.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/org/apache/tinkerpop/shaded/jackson/core/JsonProcessingException.java new file mode 100644 index 00000000..300ba775 --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/org/apache/tinkerpop/shaded/jackson/core/JsonProcessingException.java @@ -0,0 +1,23 @@ +package org.apache.tinkerpop.shaded.jackson.core; + +import java.io.IOException; + +/** + * Minimal stand-in for the relocated Jackson exception type that {@code TinkerGraph} references in a {@code catch} + * clause. + * + *

Why this exists: {@code gremlin-shaded} bundles (relocated) copies of Jackson and Kryo. The Jackson version it + * bundles contains known vulnerabilities that cannot be fixed with dependency constraints, and SFGE does not use it + * since SFGE only builds and traverses an in-memory graph (no GraphSON/Gryo/GraphML import or export). So we exclude + * {@code gremlin-shaded} from the runtime classpath (see {@code build.gradle.kts}). However, the JVM must still be able + * to load this one exception class when it verifies {@code TinkerGraph}, even though no Jackson code ever runs. + * + *

This class intentionally contains no Jackson code. Remove it (and re-evaluate the {@code gremlin-shaded} exclusion) + * when upgrading to a Gremlin release whose bundled Jackson is patched. {@code NoVulnerableBundledLibrariesTest} + * guards this behavior. + */ +public class JsonProcessingException extends IOException { + public JsonProcessingException(String message) { + super(message); + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/graph/ops/NoVulnerableBundledLibrariesTest.java b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/graph/ops/NoVulnerableBundledLibrariesTest.java new file mode 100644 index 00000000..679f3532 --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/graph/ops/NoVulnerableBundledLibrariesTest.java @@ -0,0 +1,43 @@ +package com.salesforce.graph.ops; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +/** + * Guards the dependency-hygiene decisions documented in {@code build.gradle.kts}: SFGE only needs an in-memory + * TinkerGraph, and must not ship libraries that carry known vulnerabilities. + */ +public class NoVulnerableBundledLibrariesTest { + @Test + public void inMemoryGraphWorksWithoutGremlinShaded() { + // Fails with NoClassDefFoundError if TinkerGraph needs anything from gremlin-shaded beyond what we provide. + assertNotNull(GraphUtil.getGraph()); + } + + @Test + public void gremlinShadedJacksonImplementationIsNotOnClasspath() { + assertThrows( + ClassNotFoundException.class, + () -> Class.forName("org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper")); + assertThrows( + ClassNotFoundException.class, + () -> Class.forName("org.apache.tinkerpop.shaded.jackson.core.JsonFactory")); + } + + @Test + public void commonsCollections3IsNotOnClasspath() { + assertThrows( + ClassNotFoundException.class, + () -> Class.forName("org.apache.commons.collections.FastHashMap")); + } + + @Test + public void nettyAndGremlinDriverAreNotOnClasspath() { + assertThrows(ClassNotFoundException.class, () -> Class.forName("io.netty.channel.Channel")); + assertThrows( + ClassNotFoundException.class, + () -> Class.forName("org.apache.tinkerpop.gremlin.driver.Cluster")); + } +} From 6629d6b9865f60144521dd2ed200fe2120fab006 Mon Sep 17 00:00:00 2001 From: nikhil-mittal-165 Date: Tue, 27 Oct 2026 12:27:14 +0530 Subject: [PATCH 2/6] Bump SFGE engine version to 0.26.0-SNAPSHOT Co-Authored-By: Claude Opus 5.5 (1M context) --- packages/code-analyzer-sfge-engine/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/code-analyzer-sfge-engine/package.json b/packages/code-analyzer-sfge-engine/package.json index b9583ecc..2826a8d3 100644 --- a/packages/code-analyzer-sfge-engine/package.json +++ b/packages/code-analyzer-sfge-engine/package.json @@ -1,7 +1,7 @@ { "name": "@salesforce/code-analyzer-sfge-engine", "description": "Plugin package that adds 'Salesforce Graph Engine' as an engine into Salesforce Code Analyzer", - "version": "0.25.0", + "version": "0.26.0-SNAPSHOT", "author": "The Salesforce Code Analyzer Team", "license": "BSD-3-Clause", "homepage": "https://developer.salesforce.com/docs/platform/salesforce-code-analyzer/overview", From 41605b91642fd6be2a6c93986511c0bf54bd4f94 Mon Sep 17 00:00:00 2001 From: nikhil-mittal-165 Date: Tue, 3 Nov 2026 11:44:23 +0530 Subject: [PATCH 3/6] FIX Remove stale dependency jars before copying SFGE runtime dependencies copyDependencies only added files to dist/java-lib, so an incremental build after switching branches could keep jars that were removed from the runtime classpath (Netty, AWS, shaded Jackson, etc.) and still pass the banned dependency check. Delete everything except sfge-*.jar first so the packed directory always matches a clean build. Co-Authored-By: Claude Sonnet 5.5 --- packages/code-analyzer-sfge-engine/sfge/build.gradle.kts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts b/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts index a1619f18..d4076831 100644 --- a/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts +++ b/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts @@ -88,6 +88,12 @@ tasks.jar { tasks.register("copyDependencies") { from(configurations.runtimeClasspath) // This includes all runtime dependencies into(javaLibDir) // Target directory for dependencies + // The directory is also the output of the jar task (sfge-*.jar), so we can't use Sync. Instead, remove any stale + // dependency jars left over from earlier builds (e.g. ones since removed from the runtime classpath) so that an + // incremental build packs exactly the same dependency set as a clean build. + doFirst { + delete(fileTree(javaLibDir) { exclude("sfge-*.jar") }) + } } tasks.build { dependsOn("copyDependencies") // Ensure dependencies are copied during the build process From cb5336ebca2235ecf9144fccc5f9ae27686eba3f Mon Sep 17 00:00:00 2001 From: nikhil-mittal-165 Date: Wed, 11 Nov 2026 14:46:23 +0530 Subject: [PATCH 4/6] FIX Bump Guava to 33.8.0-jre to remediate GHSA-xxph-c9ww-hj94 Guava 33.4.8-jre is affected by GHSA-xxph-c9ww-hj94 / CVE-2026-102554 (CVSS 8.2): unbounded memory allocation when deserializing CompactHashMap, CompactHashSet or MapMakerInternalMap. Fixed in 33.7.2. SFGE does no Java deserialization, but this was the only advisory osv-scanner reported on dist/java-lib after the previous commits. Co-Authored-By: Claude Sonnet 5.5 --- packages/code-analyzer-sfge-engine/gradle/libs.versions.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml index 423a8c57..2d68a3cd 100644 --- a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml +++ b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml @@ -15,7 +15,7 @@ antlr-runtime = "3.5.3" log4j-api = "2.25.5" log4j-core = "2.25.5" gson = "2.13.2" -guava = "33.4.8-jre" +guava = "33.8.0-jre" jsr305 = "3.0.2" json-simple = "1.1.1" reflections = "0.10.2" From 1646615700172e3fa0427baa1da3a1406a030816 Mon Sep 17 00:00:00 2001 From: nikhil-mittal-165 Date: Wed, 11 Nov 2026 14:46:33 +0530 Subject: [PATCH 5/6] FIX Bump commons-collections4 to 4.6.0 4.6.0 fixes a SetUniqueList.add(int, Object) bug, which is the API named by sonatype-2024-3350. SFGE does not use SetUniqueList; it only uses PredicateUtils with PredicatedMap/Set/List. osv-scanner on dist/java-lib now reports no issues. Co-Authored-By: Claude Sonnet 5.5 --- packages/code-analyzer-sfge-engine/gradle/libs.versions.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml index 2d68a3cd..f652fa2c 100644 --- a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml +++ b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml @@ -9,7 +9,7 @@ hamcrest = "3.0" junit-jupiter = "5.13.4" commons-cli = "1.10.0" -commons-collections4 = "4.5.0" +commons-collections4 = "4.6.0" tinkergraph-gremlin = "3.7.7" antlr-runtime = "3.5.3" log4j-api = "2.25.5" From fc24030e7bd1208b7907c793e444182d7d838ec6 Mon Sep 17 00:00:00 2001 From: nikhil-mittal-165 Date: Wed, 11 Nov 2026 15:28:29 +0530 Subject: [PATCH 6/6] FIX Remove commons-collections4 by replacing NonNull* collections with Guava-based classes sonatype-2024-3350 flags SetUniqueList.add(int, Object) in commons-collections4. SFGE never uses SetUniqueList; the library was only used for three 16-line classes that wrap a standard collection with a "reject null" rule (NonNullArrayList/HashMap/HashSet). Replace those wrappers with Guava Forwarding* classes so the dependency can be dropped entirely instead of relying on a waiver. Same behavior: IllegalArgumentException on null, on every write path (add/set/addAll, list iterators, subList, Map.put/putAll, entry.setValue, and the default Map methods that write through them), and a rejected bulk write leaves the collection unchanged. Adds characterization tests (14) that were first run against the old commons-collections4 implementation and pass unchanged against the new one. commons-collections4 is now also listed in verifyNoBannedDependencies. Co-Authored-By: Claude Sonnet 5.5 --- .../gradle/libs.versions.toml | 2 - .../sfge/build.gradle.kts | 4 +- .../collections/NonNullArrayList.java | 6 +- .../salesforce/collections/NonNullGuard.java | 20 ++++ .../collections/NonNullHashMap.java | 90 ++++++++++++++- .../collections/NonNullHashSet.java | 27 ++++- .../collections/NullRejectingList.java | 89 +++++++++++++++ .../collections/NonNullArrayListTest.java | 105 ++++++++++++++++++ .../collections/NonNullHashMapTest.java | 91 +++++++++++++++ .../collections/NonNullHashSetTest.java | 63 +++++++++++ 10 files changed, 480 insertions(+), 17 deletions(-) create mode 100644 packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullGuard.java create mode 100644 packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NullRejectingList.java create mode 100644 packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullArrayListTest.java create mode 100644 packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashMapTest.java create mode 100644 packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashSetTest.java diff --git a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml index f652fa2c..c4571750 100644 --- a/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml +++ b/packages/code-analyzer-sfge-engine/gradle/libs.versions.toml @@ -9,7 +9,6 @@ hamcrest = "3.0" junit-jupiter = "5.13.4" commons-cli = "1.10.0" -commons-collections4 = "4.6.0" tinkergraph-gremlin = "3.7.7" antlr-runtime = "3.5.3" log4j-api = "2.25.5" @@ -33,7 +32,6 @@ snakeyaml = "2.7" hamcrest = { module = "org.hamcrest:hamcrest", version.ref = "hamcrest" } junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" } commons-cli = { module = "commons-cli:commons-cli", version.ref = "commons-cli" } -commons-collections4 = { module = "org.apache.commons:commons-collections4", version.ref = "commons-collections4" } tinkergraph-gremlin = { module = "org.apache.tinkerpop:tinkergraph-gremlin", version.ref = "tinkergraph-gremlin" } antlr-runtime = { module = "org.antlr:antlr-runtime", version.ref = "antlr-runtime" } log4j-api = { module = "org.apache.logging.log4j:log4j-api", version.ref = "log4j-api" } diff --git a/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts b/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts index d4076831..6f845512 100644 --- a/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts +++ b/packages/code-analyzer-sfge-engine/sfge/build.gradle.kts @@ -21,7 +21,6 @@ repositories { // See https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format dependencies { implementation(libs.commons.cli) - implementation(libs.commons.collections4) implementation(libs.tinkergraph.gremlin) { // commons-collections 3.x (pulled in by commons-beanutils) has known vulnerabilities and no patched release. // SFGE and the Gremlin graph layer do not use it, so it is removed from the classpath entirely. @@ -107,7 +106,8 @@ val bannedRuntimeDependencies = mapOf( "org.apache.tinkerpop:gremlin-driver" to "SFGE only uses the embedded in-memory graph", "org.apache.tinkerpop:gremlin-util" to "SFGE only uses the embedded in-memory graph", "org.apache.tinkerpop:gremlin-shaded" to "Bundles Jackson/Kryo with known vulnerabilities that cannot be patched via constraints", - "commons-collections:commons-collections" to "3.x has known vulnerabilities and no patched release (SFGE uses commons-collections4)" + "commons-collections:commons-collections" to "3.x has known vulnerabilities and no patched release", + "org.apache.commons:commons-collections4" to "SFGE does not use it (the NonNull* collections are plain Java/Guava); sonatype-2024-3350 flags SetUniqueList in it" ) tasks.register("verifyNoBannedDependencies") { group = "verification" diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullArrayList.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullArrayList.java index 0b597205..acb22027 100644 --- a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullArrayList.java +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullArrayList.java @@ -1,13 +1,11 @@ package com.salesforce.collections; import java.util.ArrayList; -import org.apache.commons.collections4.PredicateUtils; -import org.apache.commons.collections4.list.PredicatedList; /** An ArrayList that doesn't allow null values */ -public class NonNullArrayList extends PredicatedList { +public class NonNullArrayList extends NullRejectingList { private NonNullArrayList(ArrayList list) { - super(list, PredicateUtils.notNullPredicate()); + super(list); } static NonNullArrayList newInstance() { diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullGuard.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullGuard.java new file mode 100644 index 00000000..dc61330a --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullGuard.java @@ -0,0 +1,20 @@ +package com.salesforce.collections; + +/** Rejects null values for the NonNull* collections. Throws the same exception type for every write path. */ +final class NonNullGuard { + private NonNullGuard() {} + + static T check(T item) { + if (item == null) { + throw new IllegalArgumentException("Null is not allowed in this collection"); + } + return item; + } + + /** Checks everything up front so that a rejected bulk operation leaves the collection unchanged. */ + static void checkAll(Iterable items) { + for (Object item : items) { + check(item); + } + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashMap.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashMap.java index 9a8ca301..060f072c 100644 --- a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashMap.java +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashMap.java @@ -1,16 +1,96 @@ package com.salesforce.collections; +import com.google.common.collect.ForwardingMap; +import com.google.common.collect.ForwardingMapEntry; +import com.google.common.collect.ForwardingSet; +import com.google.common.collect.Iterators; import java.util.HashMap; -import org.apache.commons.collections4.PredicateUtils; -import org.apache.commons.collections4.map.PredicatedMap; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +/** + * A HashMap that doesn't allow null keys or values. The default Map methods (putIfAbsent, merge, compute, replace, + * ...) write through {@link #put}, and replaceAll writes through the entries returned by {@link #entrySet()}, so + * guarding those two covers every write path. + */ +public class NonNullHashMap extends ForwardingMap { + private final HashMap delegate; -/** A HashMap that doesn't allow null keys or values */ -public class NonNullHashMap extends PredicatedMap { private NonNullHashMap(HashMap map) { - super(map, PredicateUtils.notNullPredicate(), PredicateUtils.notNullPredicate()); + this.delegate = map; } static NonNullHashMap newInstance() { return new NonNullHashMap<>(new HashMap<>()); } + + @Override + protected Map delegate() { + return delegate; + } + + @Override + public V put(K key, V value) { + return super.put(NonNullGuard.check(key), NonNullGuard.check(value)); + } + + @Override + public void putAll(Map map) { + NonNullGuard.checkAll(map.keySet()); + NonNullGuard.checkAll(map.values()); + super.putAll(map); + } + + @Override + public Set> entrySet() { + return new NullRejectingEntrySet<>(super.entrySet()); + } + + private static final class NullRejectingEntrySet extends ForwardingSet> { + private final Set> delegate; + + NullRejectingEntrySet(Set> delegate) { + this.delegate = delegate; + } + + @Override + protected Set> delegate() { + return delegate; + } + + @Override + public Iterator> iterator() { + return Iterators.transform(delegate.iterator(), NullRejectingEntry::new); + } + + // The inherited toArray methods would hand out the underlying (unguarded) entries. + @Override + public Object[] toArray() { + return standardToArray(); + } + + @Override + public T[] toArray(T[] array) { + return standardToArray(array); + } + } + + private static final class NullRejectingEntry extends ForwardingMapEntry { + private final Map.Entry delegate; + + NullRejectingEntry(Map.Entry delegate) { + this.delegate = delegate; + } + + @Override + protected Map.Entry delegate() { + return delegate; + } + + @Override + public V setValue(V value) { + return super.setValue(NonNullGuard.check(value)); + } + } } diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashSet.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashSet.java index 99b725a4..41d84309 100644 --- a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashSet.java +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NonNullHashSet.java @@ -1,16 +1,35 @@ package com.salesforce.collections; +import com.google.common.collect.ForwardingSet; +import java.util.Collection; import java.util.HashSet; -import org.apache.commons.collections4.PredicateUtils; -import org.apache.commons.collections4.set.PredicatedSet; +import java.util.Set; /** An HashSet that doesn't allow null values */ -public class NonNullHashSet extends PredicatedSet { +public class NonNullHashSet extends ForwardingSet { + private final HashSet delegate; + private NonNullHashSet(HashSet set) { - super(set, PredicateUtils.notNullPredicate()); + this.delegate = set; } static NonNullHashSet newInstance() { return new NonNullHashSet<>(new HashSet<>()); } + + @Override + protected Set delegate() { + return delegate; + } + + @Override + public boolean add(E element) { + return super.add(NonNullGuard.check(element)); + } + + @Override + public boolean addAll(Collection collection) { + NonNullGuard.checkAll(collection); + return super.addAll(collection); + } } diff --git a/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NullRejectingList.java b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NullRejectingList.java new file mode 100644 index 00000000..c9c4be51 --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/main/java/com/salesforce/collections/NullRejectingList.java @@ -0,0 +1,89 @@ +package com.salesforce.collections; + +import com.google.common.collect.ForwardingList; +import com.google.common.collect.ForwardingListIterator; +import java.util.Collection; +import java.util.List; +import java.util.ListIterator; + +/** + * A List view that rejects nulls on every write path, including the ones that bypass add/set: list iterators (which + * is also what {@link List#replaceAll} and {@link List#sort} write through) and sub lists. + */ +class NullRejectingList extends ForwardingList { + private final List delegate; + + NullRejectingList(List delegate) { + this.delegate = delegate; + } + + @Override + protected List delegate() { + return delegate; + } + + @Override + public boolean add(E element) { + return super.add(NonNullGuard.check(element)); + } + + @Override + public void add(int index, E element) { + super.add(index, NonNullGuard.check(element)); + } + + @Override + public boolean addAll(Collection collection) { + NonNullGuard.checkAll(collection); + return super.addAll(collection); + } + + @Override + public boolean addAll(int index, Collection elements) { + NonNullGuard.checkAll(elements); + return super.addAll(index, elements); + } + + @Override + public E set(int index, E element) { + return super.set(index, NonNullGuard.check(element)); + } + + @Override + public ListIterator listIterator() { + return new NullRejectingListIterator<>(super.listIterator()); + } + + @Override + public ListIterator listIterator(int index) { + return new NullRejectingListIterator<>(super.listIterator(index)); + } + + @Override + public List subList(int fromIndex, int toIndex) { + return new NullRejectingList<>(super.subList(fromIndex, toIndex)); + } + + private static final class NullRejectingListIterator extends ForwardingListIterator { + private final ListIterator delegate; + + NullRejectingListIterator(ListIterator delegate) { + this.delegate = delegate; + } + + @Override + protected ListIterator delegate() { + return delegate; + } + + @Override + public void add(E element) { + super.add(NonNullGuard.check(element)); + } + + @Override + public void set(E element) { + super.set(NonNullGuard.check(element)); + } + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullArrayListTest.java b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullArrayListTest.java new file mode 100644 index 00000000..484d5aec --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullArrayListTest.java @@ -0,0 +1,105 @@ +package com.salesforce.collections; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.*; +import java.util.stream.Collectors; +import org.junit.jupiter.api.Test; + +/** Pins the behavior callers rely on: nulls are rejected with IllegalArgumentException on every path. */ +public class NonNullArrayListTest { + private static NonNullArrayList listOf(String... items) { + NonNullArrayList list = NonNullArrayList.newInstance(); + list.addAll(Arrays.asList(items)); + return list; + } + + @Test + public void nullsAreRejectedOnEveryMutatingPath() { + NonNullArrayList list = listOf("a", "b"); + assertThrows(IllegalArgumentException.class, () -> list.add(null)); + assertThrows(IllegalArgumentException.class, () -> list.add(1, null)); + assertThrows(IllegalArgumentException.class, () -> list.set(0, null)); + assertThrows(IllegalArgumentException.class, () -> list.addAll(Arrays.asList("c", null))); + assertThrows(IllegalArgumentException.class, () -> list.addAll(1, Arrays.asList("c", null))); + assertThrows(IllegalArgumentException.class, () -> list.replaceAll(s -> null)); + assertThrows(IllegalArgumentException.class, () -> list.listIterator().add(null)); + assertThrows( + IllegalArgumentException.class, + () -> { + ListIterator it = list.listIterator(); + it.next(); + it.set(null); + }); + assertThrows(IllegalArgumentException.class, () -> list.subList(0, 1).add(null)); + assertThrows(IllegalArgumentException.class, () -> list.subList(0, 1).set(0, null)); + assertEquals(Arrays.asList("a", "b"), list, "a rejected write must not change the list"); + } + + @Test + public void rejectedAddAllLeavesListUnchanged() { + NonNullArrayList list = listOf("a"); + assertThrows(IllegalArgumentException.class, () -> list.addAll(Arrays.asList("b", null, "c"))); + assertEquals(Collections.singletonList("a"), list); + } + + @Test + public void validOperationsBehaveLikeArrayList() { + NonNullArrayList list = listOf("b", "a"); + list.add("c"); + list.add(0, "z"); + list.set(1, "y"); + assertEquals(Arrays.asList("z", "y", "a", "c"), list); + assertEquals(4, list.size()); + assertFalse(list.isEmpty()); + assertTrue(list.contains("a")); + assertEquals(2, list.indexOf("a")); + assertEquals("a", list.get(2)); + assertEquals("a", list.remove(2)); + assertTrue(list.remove("z")); + list.sort(Comparator.naturalOrder()); + assertEquals(Arrays.asList("c", "y"), list); + list.replaceAll(String::toUpperCase); + assertEquals(Arrays.asList("C", "Y"), list); + list.removeIf(s -> s.equals("C")); + assertEquals(Collections.singletonList("Y"), list); + assertEquals(Collections.singletonList("Y"), list.stream().collect(Collectors.toList())); + list.clear(); + assertTrue(list.isEmpty()); + } + + @Test + public void nullQueriesDoNotThrow() { + NonNullArrayList list = listOf("a"); + assertFalse(list.contains(null)); + assertEquals(-1, list.indexOf(null)); + assertFalse(list.remove(null)); + } + + @Test + public void equalsHashCodeAndToStringMatchPlainList() { + NonNullArrayList list = listOf("a", "b"); + List plain = new ArrayList<>(Arrays.asList("a", "b")); + assertEquals(plain, list); + assertEquals(list, plain); + assertEquals(list, listOf("a", "b")); + assertNotEquals(list, listOf("a")); + assertEquals(plain.hashCode(), list.hashCode()); + assertEquals(plain.toString(), list.toString()); + } + + @Test + public void iteratorRemoveAndUnmodifiableViewWork() { + NonNullArrayList list = listOf("a", "b", "c"); + Iterator it = list.iterator(); + it.next(); + it.remove(); + assertEquals(Arrays.asList("b", "c"), list); + List view = Collections.unmodifiableList(list); + assertThrows(UnsupportedOperationException.class, () -> view.add("d")); + assertEquals(Arrays.asList("b", "c"), view); + List sub = list.subList(0, 1); + sub.add("x"); + assertEquals(Arrays.asList("b", "x", "c"), list); + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashMapTest.java b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashMapTest.java new file mode 100644 index 00000000..46240aee --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashMapTest.java @@ -0,0 +1,91 @@ +package com.salesforce.collections; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.*; +import org.junit.jupiter.api.Test; + +public class NonNullHashMapTest { + private static NonNullHashMap mapOf(String... kvs) { + NonNullHashMap map = NonNullHashMap.newInstance(); + for (int i = 0; i < kvs.length; i += 2) { + map.put(kvs[i], kvs[i + 1]); + } + return map; + } + + @Test + public void nullKeysAndValuesAreRejectedOnEveryMutatingPath() { + NonNullHashMap map = mapOf("a", "1"); + assertThrows(IllegalArgumentException.class, () -> map.put(null, "x")); + assertThrows(IllegalArgumentException.class, () -> map.put("x", null)); + assertThrows(IllegalArgumentException.class, () -> map.put("a", null)); + assertThrows(IllegalArgumentException.class, () -> map.putIfAbsent("x", null)); + assertThrows(IllegalArgumentException.class, () -> map.putIfAbsent(null, "x")); + assertThrows(IllegalArgumentException.class, () -> map.replace("a", null)); + assertThrows(IllegalArgumentException.class, () -> map.replaceAll((k, v) -> null)); + assertThrows(IllegalArgumentException.class, () -> map.computeIfAbsent(null, k -> "x")); + assertThrows(IllegalArgumentException.class, () -> map.compute(null, (k, v) -> "x")); + assertThrows(IllegalArgumentException.class, () -> map.merge(null, "x", (o, n) -> n)); + assertThrows( + IllegalArgumentException.class, + () -> map.entrySet().iterator().next().setValue(null)); + Map bad = new HashMap<>(); + bad.put("ok", "1"); + bad.put("bad", null); + assertThrows(IllegalArgumentException.class, () -> map.putAll(bad)); + assertEquals(Collections.singletonMap("a", "1"), map, "a rejected write must not change the map"); + } + + @Test + public void validOperationsBehaveLikeHashMap() { + NonNullHashMap map = mapOf("a", "1", "b", "2"); + assertEquals("1", map.put("a", "10")); + assertNull(map.put("c", "3")); + assertEquals(3, map.size()); + assertEquals("10", map.get("a")); + assertTrue(map.containsKey("c")); + assertTrue(map.containsValue("3")); + assertEquals("3", map.remove("c")); + assertEquals(new HashSet<>(Arrays.asList("a", "b")), map.keySet()); + assertEquals(new HashSet<>(Arrays.asList("10", "2")), new HashSet<>(map.values())); + map.putAll(Collections.singletonMap("d", "4")); + assertEquals("4", map.get("d")); + map.entrySet().stream().filter(e -> e.getKey().equals("d")).forEach(e -> e.setValue("40")); + assertEquals("40", map.get("d")); + map.replaceAll((k, v) -> v + "!"); + assertEquals("10!", map.get("a")); + assertEquals("99", map.computeIfAbsent("z", k -> "99")); + assertEquals("98", map.merge("z", "98", (o, n) -> n)); + assertNull(map.compute("z", (k, v) -> null)); + assertFalse(map.containsKey("z")); + assertNull(map.putIfAbsent("p", "q")); + assertEquals("q", map.putIfAbsent("p", "r")); + map.clear(); + assertTrue(map.isEmpty()); + } + + @Test + public void nullQueriesDoNotThrow() { + NonNullHashMap map = mapOf("a", "1"); + assertNull(map.get(null)); + assertFalse(map.containsKey(null)); + assertFalse(map.containsValue(null)); + assertNull(map.remove(null)); + } + + @Test + public void equalsHashCodeAndToStringMatchPlainMap() { + NonNullHashMap map = mapOf("a", "1", "b", "2"); + Map plain = new HashMap<>(); + plain.put("a", "1"); + plain.put("b", "2"); + assertEquals(plain, map); + assertEquals(map, plain); + assertEquals(map, mapOf("b", "2", "a", "1")); + assertNotEquals(map, mapOf("a", "1")); + assertEquals(plain.hashCode(), map.hashCode()); + assertEquals(plain.toString(), map.toString()); + assertThrows(UnsupportedOperationException.class, () -> Collections.unmodifiableMap(map).put("x", "y")); + } +} diff --git a/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashSetTest.java b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashSetTest.java new file mode 100644 index 00000000..9bb21db1 --- /dev/null +++ b/packages/code-analyzer-sfge-engine/sfge/src/test/java/com/salesforce/collections/NonNullHashSetTest.java @@ -0,0 +1,63 @@ +package com.salesforce.collections; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.*; +import java.util.stream.Collectors; +import org.junit.jupiter.api.Test; + +public class NonNullHashSetTest { + private static NonNullHashSet setOf(String... items) { + NonNullHashSet set = NonNullHashSet.newInstance(); + set.addAll(Arrays.asList(items)); + return set; + } + + @Test + public void nullsAreRejectedOnEveryMutatingPath() { + NonNullHashSet set = setOf("a", "b"); + assertThrows(IllegalArgumentException.class, () -> set.add(null)); + assertThrows(IllegalArgumentException.class, () -> set.addAll(Arrays.asList("c", null))); + assertEquals(new HashSet<>(Arrays.asList("a", "b")), set, "a rejected write must not change the set"); + } + + @Test + public void validOperationsBehaveLikeHashSet() { + NonNullHashSet set = setOf("a", "b"); + assertFalse(set.add("a")); + assertTrue(set.add("c")); + assertEquals(3, set.size()); + assertTrue(set.contains("c")); + assertFalse(set.isEmpty()); + assertTrue(set.remove("c")); + set.removeIf(s -> s.equals("a")); + assertEquals(Collections.singleton("b"), set); + assertEquals(Collections.singletonList("b"), set.stream().collect(Collectors.toList())); + Iterator it = set.iterator(); + it.next(); + it.remove(); + assertTrue(set.isEmpty()); + set.add("x"); + set.clear(); + assertTrue(set.isEmpty()); + } + + @Test + public void nullQueriesDoNotThrow() { + NonNullHashSet set = setOf("a"); + assertFalse(set.contains(null)); + assertFalse(set.remove(null)); + } + + @Test + public void equalsHashCodeAndToStringMatchPlainSet() { + NonNullHashSet set = setOf("a", "b"); + Set plain = new HashSet<>(Arrays.asList("a", "b")); + assertEquals(plain, set); + assertEquals(set, plain); + assertEquals(set, setOf("b", "a")); + assertNotEquals(set, setOf("a")); + assertEquals(plain.hashCode(), set.hashCode()); + assertEquals(plain.toString(), set.toString()); + } +}