Skip to content

Commit 75b4daa

Browse files
mikolalysenkoclaude
andcommitted
Stop attesting Maven pins a profile or user property overrides
VEX discovery attested two Maven pins the build may not resolve: 1. Profile declarations (J1). Discovery dropped every dependency inside <profiles> from the version grouping and diagnosed only suffixed profile versions. A profile declaring the pinned GA at the base version (or any other version) left the hosted ref attested, yet whenever that profile is active Maven resolves the unpatched jar. The hosted rewriter leaves profile declarations as written (redirect_maven_profile_dependency_unpatched) and vendored mode treats every profile as live, so discovery now agrees with the writers: a profile declaration of the pinned GA (main jar in <dependencies> or <dependencyManagement>, a declaration an undefined coordinate property may make that GA, or an executable classifier copy) at any version other than the pin keeps the ref but marks it unattested with the new UnattestedKind::MavenProfileUnpatched (CLI note vex_maven_profile_unpatched). A profile declaration with no <version> takes the live pin and does not withhold it. The pre-v5 single-pom vendored wiring gets the same check against its vendored version. 2. .mvn/maven.config user properties (J4). A ${prop} <version> was resolved from the pom's <properties> only, though coordinates already read maven.config's -D user properties. Maven looks user properties up first, so <version>${v}</version> with <v>1.0-socket.x</v> in the pom and -Dv=1.0 in maven.config builds the base release while discovery attested the pin. PomScope now lays the user properties over the root <properties> once, and both version resolution and coordinate interpolation read that map. The vendored reactor's interpolator is a method on the multi-pom Reactor, so it is not reused here; this is the minimal change in formats/maven. Tests (each fails on origin/main): - formats::maven::tests::version_property_reads_user_properties_first - vex::discover::maven::tests::version_property_reads_maven_config_overrides - vex::discover::maven::tests::profile_declaration_off_the_pin_is_not_attested - vex::discover::maven::tests::vendored_ref_under_a_profile_version_is_not_attested No existing test asserted the old behavior; the golden corpus is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1 parent 7bde3ba commit 75b4daa

5 files changed

Lines changed: 323 additions & 14 deletions

File tree

‎crates/socket-patch-cli/CLI_CONTRACT.md‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -547,7 +547,7 @@ Recognition rules that hold for every ecosystem:
547547
* **Patch hosts.** A hosted reference counts only on `https://patch.socket.dev` or the `--patch-server-url` / `SOCKET_PATCH_SERVER_URL` origin, with no userinfo. The uuid is the URL's LAST canonical-uuid path segment, because grant tokens may themselves be uuid-shaped. The Go module prefix is fixed. `socket-patch-<uuid>` registry / repository / source names count only through a pin. For a URL on any other host, see **Patch hosts** above.
548548
* **Pins, not definitions.** A registry, index or source *definition* alone (cargo `[registries]`, nuget `<add>`, pom `<repository>`, uv index tables, `.npmrc`) never makes a reference, because it survives a reverted pin. Sections the package manager ignores are not read: npm's v2 `dependencies` mirror, a `.cargo/config.toml` shadowed by `.cargo/config`. A Socket pin inside a maven `<profile>` is diagnosed, never a reference.
549549
* **Contested locks.** When one lock wires a package to a patch and another lock resolves the same `name@version` from a non-Socket source, the build's bytes depend on which package manager runs. The reference is then dropped with a `patched_ref_unattributable` diagnostic naming both files. This applies across npm / pnpm / yarn / bun and across uv / pylock / poetry / pdm / Pipfile.lock / requirements. PEP 723 script locks neither contest nor are contested. The root `requirements.txt` and its in-root `-r` includes count as one lock here: pip reads them as one requirement set, where a direct reference wins over a compatible `==` pin of the same version in another file of the set (#1086). A PyPI version matches under PEP 440 equality, so a requirements line pinned in any spelling that can only install the wired release (`==1.2.3.0`, `==v1.2.3`, `===1.2.3`) contests it like `==1.2.3` does; a range or wildcard (`~=1.2.3`, `==1.2.*`) does not (#1602). A **bundled** npm copy (`inBundle: true`, or v1 `bundled: true`, beneath a dependency that bundles it; the root project's own bundles install from the lock, #1618) of the same `name@version` contests the reference too, in the same lock, in the other npm lock of a shrinkwrap/package-lock pair, or in any other lock. npm unpacks it from the parent package's tarball, so no rewire reaches it and it stays unpatched. Bun and vlt unpack bundled copies the same way (#469, #471). pnpm unpacks bundled copies too, but its lock cannot tie one to a reference (see **Unattested references** below). For Bun, that is a `bun.lock` entry whose meta is `{ "bundled": true }`, or a `bun.lockb` record that a dependency edge with the `bundled` behavior bit reaches, including one Bun shares with a regular install. Such an entry is never a reference, and it contests the reference the same way. For vlt, the lock records no node for a bundled copy, so the copy is found in the installed store: a real package directory inside a store package's own `node_modules`. yarn classic's `yarn.lock` records nothing about bundled copies either (#758), so for a lock with a Socket wiring they are found in the installed `node_modules`: each package a parent's `bundleDependencies` / `bundledDependencies` names inside the parent's own `node_modules`, the dependencies of those beside them, and everything nested under them. Such a copy contests the reference in `yarn.lock` (the diagnostic names the parent's lock entry and the copy's directory); a lock-only `vex` with no `node_modules` can't see it. Hosted and vendored scans skip these copies with `redirect_bun_bundled_instance_skipped` / `redirect_vlt_bundled_instance_skipped` / `vendor_bundled_instance_skipped`, and a yarn classic hosted scan names one with `redirect_copy_unpatched`. When a bundled copy is the only instance, vendoring refuses with `vendor_lock_entry_not_rewritable`. A reference withheld only because such an unreachable copy installs beside it (a bundled npm / Bun / vlt copy, an npm copy beneath a `hasShrinkwrap` package (#753) or one npm installs from a git / url / `file:` spec, or a yarn classic git or `file:` directory block of the same `name@version`) is still the rewriter's own wiring of exactly one package version: it is never attested, but `rollback`, `remove`, `list` and the hosted → vendored takeover treat it as an ordinary hosted pin and restore its upstream registry entry (#828), rather than refusing it with `hosted_wiring_contested`. Another entry of the **same** npm, Bun or yarn lock that resolves the wired `name@version` from a non-Socket source (for example a workspace member added after the rewire, then `npm install` / `bun install` / `yarn install`; for yarn berry, a registry locator such as `left-pad@npm:1.3.0` beside the hosted `…::__archiveUrl=` one) contests the reference too (#588). The package manager installs both entries, and that copy stays unpatched. Re-running `scan` / `vendor` rewires every copy.
550-
* **Unattested references.** Some evidence shows a build may run a copy no wiring reaches, but cannot be tied to the reference's exact `name@version` or cannot say the build runs it. The reference then stays a reference: `list`, `rollback` and `remove` find it, and the ledgers' liveness gates (`vendor --check`, `scan`) keep treating the wiring as live, because re-running `scan` / `vendor` could never clear the evidence. Only `vex` omits it, as a run warning and as the `failed[].reason`. Four cases besides Gradle's (`vex_gradle_lock_above_base`): **pnpm bundled copies** (`vex_pnpm_bundled_copy`): a `packages:` entry's `bundledDependencies:` names the copies pnpm unpacks from that package's own tarball, but pnpm never locks them, so the bundled version is not in the lock. A pnpm reference whose package name a `bundledDependencies` list in the same lock names is omitted whatever its version (a missed attestation when the bundled copy is another version, never a false one), and `bundledDependencies: true` (or a value that cannot be read) omits every reference of that lock. It reaches no other lock. **deno.lock** (`vex_deno_lock_copy`): `deno install` installs a `package.json` project's npm dependencies from `deno.lock` and never reads `package-lock.json` / `pnpm-lock.yaml` / `yarn.lock`, so an npm-family reference whose `name@version` the `deno.lock` npm section also locks is omitted (#406). Whether Deno or another package manager populates `node_modules` (`nodeModulesDir: "manual"` allows either) is not in the files, so this holds whatever `nodeModulesDir` says. **Maven reactor roots** (`vex_maven_reactor_root`): a hosted pin in a root `pom.xml` that declares `<modules>` / `<subprojects>`, or whose subprojects Maven 4 discovers (see the hosted Maven rewriter), is omitted, because a module's own literal `<version>` overrides a root pin and module poms are not read (#261); hosted scan refuses such roots (`redirect_maven_multimodule_unsupported`), so this only covers pins an older release wrote. **Maven classifier copies** (`vex_maven_classifier_unpatched`): a `<classifier>` dependency of a hosted-pinned GA is its own coordinate; the classifier-less pin does not retarget it and the grant serves only the main jar, so Maven fetches it from the next repository. When a live, non-profile classifier copy other than `sources` / `javadoc` (`tests`, a native or JDK-specific build) resolves any version other than the suffixed pin — its own literal `<version>`, a `<dependencyManagement>` entry with the same classifier, or no version in the root pom — the pin is omitted. `sources` / `javadoc` copies never run on a classpath and do not withhold the statement; hosted scan only warns about them (`redirect_maven_classifier_unsupported`) and skips the dep when an executable copy names the patched release.
550+
* **Unattested references.** Some evidence shows a build may run a copy no wiring reaches, but cannot be tied to the reference's exact `name@version` or cannot say the build runs it. The reference then stays a reference: `list`, `rollback` and `remove` find it, and the ledgers' liveness gates (`vendor --check`, `scan`) keep treating the wiring as live, because re-running `scan` / `vendor` could never clear the evidence. Only `vex` omits it, as a run warning and as the `failed[].reason`. Five cases besides Gradle's (`vex_gradle_lock_above_base`): **pnpm bundled copies** (`vex_pnpm_bundled_copy`): a `packages:` entry's `bundledDependencies:` names the copies pnpm unpacks from that package's own tarball, but pnpm never locks them, so the bundled version is not in the lock. A pnpm reference whose package name a `bundledDependencies` list in the same lock names is omitted whatever its version (a missed attestation when the bundled copy is another version, never a false one), and `bundledDependencies: true` (or a value that cannot be read) omits every reference of that lock. It reaches no other lock. **deno.lock** (`vex_deno_lock_copy`): `deno install` installs a `package.json` project's npm dependencies from `deno.lock` and never reads `package-lock.json` / `pnpm-lock.yaml` / `yarn.lock`, so an npm-family reference whose `name@version` the `deno.lock` npm section also locks is omitted (#406). Whether Deno or another package manager populates `node_modules` (`nodeModulesDir: "manual"` allows either) is not in the files, so this holds whatever `nodeModulesDir` says. **Maven reactor roots** (`vex_maven_reactor_root`): a hosted pin in a root `pom.xml` that declares `<modules>` / `<subprojects>`, or whose subprojects Maven 4 discovers (see the hosted Maven rewriter), is omitted, because a module's own literal `<version>` overrides a root pin and module poms are not read (#261); hosted scan refuses such roots (`redirect_maven_multimodule_unsupported`), so this only covers pins an older release wrote. **Maven classifier copies** (`vex_maven_classifier_unpatched`): a `<classifier>` dependency of a hosted-pinned GA is its own coordinate; the classifier-less pin does not retarget it and the grant serves only the main jar, so Maven fetches it from the next repository. When a live, non-profile classifier copy other than `sources` / `javadoc` (`tests`, a native or JDK-specific build) resolves any version other than the suffixed pin — its own literal `<version>`, a `<dependencyManagement>` entry with the same classifier, or no version in the root pom — the pin is omitted. `sources` / `javadoc` copies never run on a classpath and do not withhold the statement; hosted scan only warns about them (`redirect_maven_classifier_unsupported`) and skips the dep when an executable copy names the patched release. **Maven profile declarations** (`vex_maven_profile_unpatched`): a `<profiles>` declaration in the root `pom.xml` of a pinned GA — its main jar in `<dependencies>` or `<dependencyManagement>`, or an executable classifier copy — at any version other than the pin (the base release, another release, a `${property}` the pom does not resolve, an executable classifier copy with no version of its own) overrides the pin whenever that profile is active, so the reference is omitted. Activation is not evaluated: every profile counts, as in vendored mode, which rewrites profile declarations too; hosted scan leaves them as written (`redirect_maven_profile_dependency_unpatched`). A profile declaration without a `<version>` takes the live pin and does not withhold the statement. The same holds for a pre-v5 single-pom vendored repository, which serves only the original version.
551551
* **Shrinkwrap without a twin (#899).** npm >= 12 never reads `npm-shrinkwrap.json`: on a project whose only npm lock is the shrinkwrap it resolves the tree from the registry and writes a fresh `package-lock.json`, so a Socket reference there reaches npm <= 11 only. The reference is still discovered, so `list`, `rollback` and `remove` manage it, but `vex` omits the patch (`vex_npm_shrinkwrap_only`, as a run warning and as the `failed[].reason`). A `package-lock.json` beside it (wired the same way) makes it attestable again. Hosted and vendored runs still rewire the shrinkwrap and warn `redirect_npm_shrinkwrap_only` / `vendor_npm_shrinkwrap_only`.
552552
* **Lockless pins.** With no lock to name a version, a `Cargo.toml` pin (every declaration on `socket-patch-<uuid>`, that registry defined on the patch host for the same uuid) or an exclusive nuget exact-id mapping is never a reference on its own, so v5.0 does not attest it (nor does `list` show it, or `rollback` / `remove` restore it — restore those files from version control). Only a pre-v5 redirect-ledger record naming a version the pin admits keeps it live. The same holds for a gem wired only in the `Gemfile` (the pre-bundler-2.6 mixed state, lock not converged).
553553

@@ -2678,6 +2678,7 @@ match it, withholds the statement:
26782678
| `vex_deno_lock_copy` | run warning and `failed[].reason` | An npm pin is wired, but `deno.lock` locks the same `name@version`, which `deno install` installs without the wiring; no statement while it does. `vendor --check` and `scan` still treat the wiring as live. |
26792679
| `vex_maven_reactor_root` | run warning and `failed[].reason` | A hosted Maven pin sits in a root `pom.xml` that declares `<modules>` / `<subprojects>` (a profile's included), where a module's own literal `<version>` overrides it; only the root pom is read, so no statement (#261). `list`, `rollback` and `remove` still find the pin. |
26802680
| `vex_maven_classifier_unpatched` | run warning and `failed[].reason` | A hosted Maven pin's GA also has a live executable `<classifier>` copy (not `sources` / `javadoc`) at a version other than the pin, which the classifier-less pin does not retarget and the grant does not serve; no statement while it does. `list`, `rollback` and `remove` still find the pin. |
2681+
| `vex_maven_profile_unpatched` | run warning and `failed[].reason` | A Maven pin's GA is also declared inside `<profiles>` in the root `pom.xml` at a version other than the pin (or as an executable classifier copy off it), which overrides the pin whenever that profile is active; no statement while it does. `list`, `rollback` and `remove` still find the pin. |
26812682
| `vex_gradle_derived_cache_unchecked` | run warning | The derived-cache walk was cut short (a very large transforms cache); the statement is still emitted, the copies the walk did reach were checked. |
26822683

26832684
A vendored Gradle entry attests only while its wiring is live (apply line, index rows,

‎crates/socket-patch-cli/src/commands/vex_sources.rs‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -232,6 +232,10 @@ const NOTE_MAVEN_REACTOR_ROOT: &str = "vex_maven_reactor_root";
232232
/// classifier copy at another version, which the pin does not reach
233233
/// (`vex::Unattested`).
234234
const NOTE_MAVEN_CLASSIFIER_UNPATCHED: &str = "vex_maven_classifier_unpatched";
235+
/// Omission tag and note: a hosted Maven pin's GA is also declared inside
236+
/// `<profiles>` at another version, which overrides the pin whenever that
237+
/// profile is active (`vex::Unattested`).
238+
const NOTE_MAVEN_PROFILE_UNPATCHED: &str = "vex_maven_profile_unpatched";
235239

236240
/// The omission tag of an [`Unattested`](socket_patch_core::vex::Unattested)
237241
/// ref, and the remedy its note ends with.
@@ -268,6 +272,12 @@ fn unattested_note(kind: UnattestedKind) -> (&'static str, &'static str) {
268272
"not attested while that classifier copy resolves an unpatched version; the \
269273
wiring itself is intact, so re-running `scan` does not change this",
270274
),
275+
UnattestedKind::MavenProfileUnpatched => (
276+
NOTE_MAVEN_PROFILE_UNPATCHED,
277+
"not attested while a profile declares it at another version; the wiring itself is \
278+
intact, so re-running `scan` does not change this (drop that profile <version> or \
279+
set it to the pin, or re-patch with `scan --mode vendored`)",
280+
),
271281
}
272282
}
273283

‎crates/socket-patch-core/src/formats/maven/mod.rs‎

Lines changed: 41 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -41,8 +41,9 @@ pub(crate) struct PomRepo {
4141
pub(crate) struct PomDep {
4242
pub(crate) group: String,
4343
pub(crate) artifact: String,
44-
/// Trimmed literal version, `${prop}` resolved from the root
45-
/// `<properties>` when possible; `None` when the declaration has none.
44+
/// Trimmed literal version, `${prop}` resolved (one level) from the
45+
/// build's user properties, else the root `<properties>`, when
46+
/// possible; `None` when the declaration has none.
4647
pub(crate) version: Option<String>,
4748
/// The non-empty `<classifier>`: a sibling artifact of the GA (sources,
4849
/// tests, a native build), managed and resolved apart from the main jar.
@@ -67,7 +68,8 @@ pub(crate) struct PomScope {
6768
pub(crate) masked: String,
6869
ignored: Vec<Element>,
6970
profiles: Vec<Element>,
70-
/// The root `<properties>` (see [`properties`]).
71+
/// The root `<properties>` (see [`properties`]) with the build's user
72+
/// properties laid over them: what a `${name}` resolves to.
7173
properties: BTreeMap<String, String>,
7274
/// [`Self::properties`] plus the `${project.*}` model references a
7375
/// coordinate may name (see [`model_refs`]).
@@ -84,8 +86,8 @@ impl PomScope {
8486

8587
/// [`Self::new`], with the user properties the build passes Maven
8688
/// (`.mvn/maven.config`'s `-D`, see [`maven_config_properties`]): they
87-
/// override a same-named pom property when a coordinate is
88-
/// interpolated, as Maven's model interpolator reads them after the
89+
/// override a same-named pom property when a coordinate or a version is
90+
/// interpolated, as Maven's model interpolator looks them up before the
8991
/// model's own.
9092
pub(crate) fn with_user_properties(
9193
raw: &str,
@@ -103,9 +105,9 @@ impl PomScope {
103105
]
104106
.concat();
105107
let profiles = elements(&masked, "profiles")?;
106-
let properties = properties(&masked, &ignored, &profiles)?;
108+
let mut properties = properties(&masked, &ignored, &profiles)?;
109+
properties.extend(user.iter().map(|(k, v)| (k.clone(), v.clone())));
107110
let mut coordinate_refs = properties.clone();
108-
coordinate_refs.extend(user.iter().map(|(k, v)| (k.clone(), v.clone())));
109111
// A `project.*` / `pom.*` reference names the model, whatever a
110112
// same-named property says; the deprecated bare form yields to one.
111113
for (name, value) in model_refs(&masked, &coordinate_refs.clone())? {
@@ -733,6 +735,38 @@ mod tests {
733735
assert!(!scope.coordinate_refs.contains_key("project.version"));
734736
}
735737

738+
/// Maven's model interpolator reads user properties (`.mvn/maven.config`'s
739+
/// `-D`) before the pom's own `<properties>`, for a `<version>` just as
740+
/// for a coordinate: `-Dv=1.0` makes `${v}` the base release whatever
741+
/// the pom defines.
742+
#[test]
743+
fn version_property_reads_user_properties_first() {
744+
let pom = "<project><properties><v>1.0-socket.77777777</v><w>2</w></properties>\
745+
<dependencies>\
746+
<dependency><groupId>g</groupId><artifactId>a</artifactId><version>${v}</version></dependency>\
747+
<dependency><groupId>g</groupId><artifactId>b</artifactId><version>${w}</version></dependency>\
748+
<dependency><groupId>g</groupId><artifactId>c</artifactId><version>${u}</version></dependency>\
749+
</dependencies></project>";
750+
let versions = |user: &[(&str, &str)]| {
751+
let user = user
752+
.iter()
753+
.map(|(k, v)| (k.to_string(), v.to_string()))
754+
.collect();
755+
super::parse_pom_with(pom, &user)
756+
.unwrap()
757+
.deps
758+
.into_iter()
759+
.map(|d| d.version.unwrap())
760+
.collect::<Vec<_>>()
761+
};
762+
assert_eq!(versions(&[]), ["1.0-socket.77777777", "2", "${u}"]);
763+
assert_eq!(
764+
versions(&[("v", "1.0"), ("u", "3")]),
765+
["1.0", "2", "3"],
766+
"a user property wins over the pom's and defines one it lacks"
767+
);
768+
}
769+
736770
#[test]
737771
fn suffix_grammar_is_exact() {
738772
assert_eq!(

0 commit comments

Comments
 (0)