From 4987825358e6433f66c21de1dccd22fb61fcac30 Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Tue, 17 Nov 2026 16:53:30 +0100 Subject: [PATCH 1/2] fix(driver-podman): allow runtime-added groups for GPU and CDI requests Set the extra-supplementary-groups claim whenever a GPU or CDI device is requested, matching the Docker driver, so CDI additionalGids no longer fail sandbox startup under the default userns mode. Persist the claim in restart metadata so restarts keep it. Closes #5305 Signed-off-by: Evan Lezar --- crates/openshell-driver-podman/README.md | 7 ++ crates/openshell-driver-podman/src/driver.rs | 7 +- .../openshell-driver-podman/src/isolation.rs | 69 +++++++++++++++++++ 3 files changed, 81 insertions(+), 2 deletions(-) diff --git a/crates/openshell-driver-podman/README.md b/crates/openshell-driver-podman/README.md index 87a617069e..50048f6b47 100644 --- a/crates/openshell-driver-podman/README.md +++ b/crates/openshell-driver-podman/README.md @@ -93,6 +93,13 @@ supplementary groups. Root and unresolved identities fail before provisioning. Images must not prepopulate the reserved `/.openshell` hierarchy; this prevents image-controlled symlinks from aliasing private control state into user mounts. +The sandbox requires the workload's supplementary groups to equal the resolved +identity. The driver relaxes that to "must include the resolved groups" only +when a GPU or CDI device is requested (CDI `containerEdits.additionalGids` adds +groups at container creation) or the user namespace is `keep-id`. Extra groups +may extend but never replace the image-derived identity. The claim is persisted +in the restart metadata so restarts keep it. + `sandbox_runtime_image` supplies the statically linked musl `/openshell-sandbox` binary. Podman's read-only image volume delivers it to the workload; user-namespace modes that cannot use image volumes retain the trusted diff --git a/crates/openshell-driver-podman/src/driver.rs b/crates/openshell-driver-podman/src/driver.rs index 6bea5b7f16..1234f53d71 100644 --- a/crates/openshell-driver-podman/src/driver.rs +++ b/crates/openshell-driver-podman/src/driver.rs @@ -1540,8 +1540,9 @@ impl PodmanComputeDriver { host_gateway_ip, identity: &identity, allow_extra_supplementary_groups: - crate::isolation::userns_preserves_host_groups( + crate::isolation::allow_extra_supplementary_groups( self.config.userns.as_deref(), + gpu_devices.is_some(), ), child_env, launch_authentication: &launch_authentication, @@ -2160,8 +2161,9 @@ impl PodmanComputeDriver { .map_err(ComputeDriverError::from)?, identity: &restart_metadata.workload_identity, allow_extra_supplementary_groups: - crate::isolation::userns_preserves_host_groups( + crate::isolation::allow_extra_supplementary_groups( self.config.userns.as_deref(), + restart_metadata.allow_extra_supplementary_groups, ), child_env: restart_metadata.child_env, launch_authentication: launch_authentication.as_ref().expect("checked above"), @@ -4474,6 +4476,7 @@ mod tests { generation: "generation-1".to_string(), workload_identity: identity, child_env: HashMap::new(), + allow_extra_supplementary_groups: false, }) .unwrap(); let mut header = tar::Header::new_gnu(); diff --git a/crates/openshell-driver-podman/src/isolation.rs b/crates/openshell-driver-podman/src/isolation.rs index f9fc790588..80b6b255e4 100644 --- a/crates/openshell-driver-podman/src/isolation.rs +++ b/crates/openshell-driver-podman/src/isolation.rs @@ -69,6 +69,14 @@ pub fn userns_preserves_host_groups(userns: Option<&str>) -> bool { userns.is_some_and(|mode| mode.split(':').next() == Some("keep-id")) } +/// Whether the sandbox process may hold supplementary groups beyond the +/// resolved workload identity. A GPU or CDI device request can add groups at +/// container creation (CDI `containerEdits.additionalGids`), independent of the +/// user-namespace mode, so the claim is set for either reason. +pub fn allow_extra_supplementary_groups(userns: Option<&str>, gpu_requested: bool) -> bool { + gpu_requested || userns_preserves_host_groups(userns) +} + fn invalid(error: impl std::fmt::Display) -> ComputeDriverError { ComputeDriverError::Precondition(error.to_string()) } @@ -188,6 +196,9 @@ pub struct RestartMetadata { pub(crate) runtime_initiated: bool, pub(crate) workload_identity: ResolvedWorkloadIdentity, pub(crate) child_env: HashMap, + /// Persisted so a restart keeps the claim a GPU/CDI request required. + #[serde(default)] + pub(crate) allow_extra_supplementary_groups: bool, } pub struct BootstrapArchivesInput<'a> { @@ -341,6 +352,7 @@ pub fn bootstrap_archives( generation: generation.to_string(), workload_identity: identity.clone(), child_env, + allow_extra_supplementary_groups, }; supervisor.file( RESTART_METADATA_PATH, @@ -646,4 +658,61 @@ mod tests { assert!(!userns_preserves_host_groups(Some("private"))); assert!(!userns_preserves_host_groups(None)); } + + #[test] + fn gpu_or_cdi_request_allows_extra_groups_under_any_userns_mode() { + assert!(allow_extra_supplementary_groups(None, true)); + assert!(allow_extra_supplementary_groups(Some("auto"), true)); + assert!(allow_extra_supplementary_groups(Some("keep-id"), false)); + assert!(!allow_extra_supplementary_groups(None, false)); + assert!(!allow_extra_supplementary_groups(Some("auto"), false)); + } + + #[test] + fn extra_groups_claim_is_projected_and_persisted_for_restart() { + let identity = ResolvedWorkloadIdentity::new( + 1000, + 1001, + vec![], + "image".into(), + "sha256:image".into(), + ) + .unwrap(); + let archives = bootstrap_archives(BootstrapArchivesInput { + runtime_initiated: false, + sandbox_id: "sandbox", + container_id: "container", + generation: "generation-1", + host_gateway_ip: "127.0.0.1".parse().unwrap(), + identity: &identity, + allow_extra_supplementary_groups: allow_extra_supplementary_groups(None, true), + child_env: HashMap::new(), + launch_authentication: &authentication(), + }) + .unwrap(); + let workload = files(&archives.channel); + let supervisor = files(&archives.supervisor); + let config: BoundaryConfig = serde_json::from_slice( + workload + .get(&PathBuf::from("sandbox/bootstrap.json")) + .unwrap(), + ) + .unwrap(); + assert_eq!( + config + .resource_claims + .get(ALLOW_EXTRA_SUPPLEMENTARY_GROUPS_RESOURCE_CLAIM) + .map(String::as_str), + Some("true") + ); + let restart_metadata: RestartMetadata = serde_json::from_slice( + supervisor + .get(&PathBuf::from( + RESTART_METADATA_PATH.trim_start_matches('/'), + )) + .unwrap(), + ) + .unwrap(); + assert!(restart_metadata.allow_extra_supplementary_groups); + } } From 865c0075a061e7bf7ff28685ac2bfffeec06ea10 Mon Sep 17 00:00:00 2001 From: Evan Lezar Date: Tue, 17 Nov 2026 17:39:25 +0100 Subject: [PATCH 2/2] test(features): restore CDI device-node-with-gid scenario Covers a CDI additionalGids group on the Docker and Podman drivers. Refs #5305. Signed-off-by: Evan Lezar --- tests/suites/features/cdi/tests/injection.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/tests/suites/features/cdi/tests/injection.rs b/tests/suites/features/cdi/tests/injection.rs index 40e6468567..9f14a6d2b1 100644 --- a/tests/suites/features/cdi/tests/injection.rs +++ b/tests/suites/features/cdi/tests/injection.rs @@ -86,3 +86,13 @@ async fn device_node(cx: &mut Context) -> testkit::Result { async fn unix_socket(cx: &mut Context) -> testkit::Result { cdi::scenario(cx, "unix-socket").await } + +/// A device node that is mode 0660 with a group only the CDI spec's +/// `additionalGids` grants. The workload must run as a non-root user, be a +/// member of the node's group, and be denied the write the expectations record. +/// This covers a group added at runtime, which the sandbox must accept from the +/// Docker and Podman drivers alike. +#[testkit::test] +async fn device_node_with_gid(cx: &mut Context) -> testkit::Result { + cdi::scenario(cx, "device-node-with-gid").await +}