Skip to content

Commit 1eea0e0

Browse files
committed
refactor(runtime): keep supervisor process access boundary driven
Signed-off-by: Drew Newberry <anewberry@nvidia.com>
1 parent 2b705bd commit 1eea0e0

10 files changed

Lines changed: 221 additions & 348 deletions

File tree

‎.agents/skills/build-openshell-mxc-windows/SKILL.md‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,10 @@ checks and tests. Their gateway session, boundary attachment, and TCP readiness
2626
are portable; only the optional Unix SSH/readiness socket adapters are gated.
2727
This is compile and control-plane coverage, not Windows isolation qualification.
2828
Preserve readiness gating on authenticated gateway acceptance and reconnection.
29+
The supervisor process-access multiplexer consumes boundary-provided streams;
30+
do not restore local PID, PTY, or process-group operations there. Native process
31+
mechanics belong to the sandbox or isolation backend. Keep the optional Unix
32+
SSH access adapter separate from portable session orchestration.
2933
Shared Sandbox Protocol audit validation defaults to strict Linux evidence;
3034
concrete platform validators must be selected by the implementing backend.
3135

‎Cargo.lock‎

Lines changed: 0 additions & 1 deletion
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎crates/openshell-sandbox-backend/README.md‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@ the execution outcome unknown.
2424

2525
Exec envelopes without an expiration time are rejected. Update the supervisor
2626
and sandbox runtime together when deploying this protocol change.
27+
2728
## Boundary audit validation
2829

2930
`OpenShellRuntimeBackend` implements the authenticated host side of the shared
@@ -37,3 +38,11 @@ not bypass generation, session, resource, identity, or outer-fence checks.
3738

3839
Concrete platform validators belong to the implementing backend, not this
3940
shared transport library.
41+
42+
## Boundary transport establishment
43+
44+
Backends may supply a `BoundaryTransportConnector` for raw stream establishment.
45+
The shared client retains TLS peer verification, session bearer authentication,
46+
generation checks, and reconnection handling. The connector is reused for policy
47+
discovery and attachment; it does not define platform launch configuration or
48+
replace the isolation interface.

‎crates/openshell-sandbox-backend/src/lib.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ pub mod mediation;
1414
mod runtime;
1515
pub mod sandbox_auth;
1616

17-
pub use runtime::OpenShellRuntimeBackend;
17+
pub use runtime::{BoundaryTransportConnector, OpenShellRuntimeBackend};
1818

1919
/// Stable isolation backend name implemented by `openshell-sandbox`.
2020
pub const BACKEND_NAME: &str = "openshell-sandbox";

‎crates/openshell-sandbox-backend/src/runtime.rs‎

Lines changed: 158 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -70,9 +70,20 @@ fn begin_recovery_window(
7070
*deadline.get_or_insert(failure_time + CONNECT_RETRY_TIMEOUT)
7171
}
7272

73+
/// Backend-owned raw transport establishment; shared code still authenticates
74+
/// the resulting stream with generation-pinned TLS and Sandbox Protocol JWTs.
75+
#[async_trait]
76+
pub trait BoundaryTransportConnector: std::fmt::Debug + Send + Sync {
77+
async fn connect(
78+
&self,
79+
descriptor: &SandboxRuntimeDescriptor,
80+
) -> Result<BoundaryDuplexStream, BackendError>;
81+
}
82+
7383
/// Host-side `OpenShell` Sandbox Protocol implementation registered with the supervisor.
7484
#[derive(Debug)]
7585
pub struct OpenShellRuntimeBackend {
86+
connector: Option<Arc<dyn BoundaryTransportConnector>>,
7687
audit_validator: Arc<dyn crate::audit::BoundaryAuditValidator>,
7788
ca_file_paths: Arc<std::sync::Mutex<Option<(PathBuf, PathBuf)>>>,
7889
provider_credentials: openshell_core::provider_credentials::ProviderCredentialState,
@@ -85,7 +96,16 @@ impl OpenShellRuntimeBackend {
8596
descriptor: SandboxRuntimeDescriptor,
8697
bearer: openshell_core::jwt::SessionBearerTokenSlot,
8798
) -> Result<(Option<String>, bool), BackendError> {
88-
let client = BoundaryClient::new(descriptor, bearer);
99+
Self::discover_policy_with_connector(descriptor, bearer, None).await
100+
}
101+
102+
pub async fn discover_policy_with_connector(
103+
descriptor: SandboxRuntimeDescriptor,
104+
bearer: openshell_core::jwt::SessionBearerTokenSlot,
105+
connector: Option<Arc<dyn BoundaryTransportConnector>>,
106+
) -> Result<(Option<String>, bool), BackendError> {
107+
let mut client = BoundaryClient::new(descriptor, bearer);
108+
client.connector = connector;
89109
match client.call_idempotent(Request::DiscoverPolicy).await? {
90110
Response::ImagePolicy { yaml, invalid } => Ok((yaml, invalid)),
91111
_ => Err(BackendError::Descriptor(
@@ -100,13 +120,23 @@ impl OpenShellRuntimeBackend {
100120
sandbox_bearer: openshell_core::jwt::SessionBearerTokenSlot,
101121
) -> Self {
102122
Self {
123+
connector: None,
103124
audit_validator: Arc::new(crate::audit::LinuxBoundaryAuditValidator),
104125
ca_file_paths,
105126
provider_credentials,
106127
sandbox_bearer,
107128
}
108129
}
109130

131+
#[must_use]
132+
pub fn with_transport_connector(
133+
mut self,
134+
connector: Arc<dyn BoundaryTransportConnector>,
135+
) -> Self {
136+
self.connector = Some(connector);
137+
self
138+
}
139+
110140
/// Select the backend implementation that validates opaque audit evidence.
111141
#[must_use]
112142
pub fn with_audit_validator(
@@ -139,10 +169,9 @@ impl IsolationBackend for OpenShellRuntimeBackend {
139169
let generation = runtime_descriptor.generation.clone();
140170
let session_id = runtime_descriptor.session_id;
141171
let outer_fence = runtime_descriptor.outer_fence.clone();
142-
let client = Arc::new(BoundaryClient::new(
143-
runtime_descriptor,
144-
self.sandbox_bearer.clone(),
145-
));
172+
let mut client = BoundaryClient::new(runtime_descriptor, self.sandbox_bearer.clone());
173+
client.connector = self.connector.clone();
174+
let client = Arc::new(client);
146175
let response = client
147176
.call_idempotent(Request::Attach {
148177
supervisor_instance_id: client.supervisor_instance_id,
@@ -1096,6 +1125,7 @@ async fn dispatch_client_mediation_frame(
10961125
}
10971126

10981127
struct BoundaryClient {
1128+
connector: Option<Arc<dyn BoundaryTransportConnector>>,
10991129
runtime_descriptor: SandboxRuntimeDescriptor,
11001130
supervisor_instance_id: crate::boundary_protocol::SupervisorInstanceId,
11011131
sandbox_bearer: openshell_core::jwt::SessionBearerTokenSlot,
@@ -1259,6 +1289,7 @@ impl BoundaryClient {
12591289
sandbox_bearer: openshell_core::jwt::SessionBearerTokenSlot,
12601290
) -> Self {
12611291
Self {
1292+
connector: None,
12621293
runtime_descriptor,
12631294
supervisor_instance_id: crate::boundary_protocol::SupervisorInstanceId::new(),
12641295
sandbox_bearer,
@@ -1880,6 +1911,7 @@ impl BoundaryClient {
18801911
&self,
18811912
) -> Result<(tonic::transport::Channel, Arc<TransportAbort>), BackendError> {
18821913
let runtime_descriptor = self.runtime_descriptor.clone();
1914+
let connector = self.connector.clone();
18831915
let transport = Arc::new(TransportAbort::default());
18841916
let connector_transport = transport.clone();
18851917
let endpoint =
@@ -1893,14 +1925,15 @@ impl BoundaryClient {
18931925
let channel = endpoint
18941926
.connect_with_connector(tower::service_fn(move |_: tonic::transport::Uri| {
18951927
let runtime_descriptor = runtime_descriptor.clone();
1928+
let connector = connector.clone();
18961929
let abort = connector_transport.clone();
18971930
async move {
18981931
// A channel is one authenticated connection. Never let it
18991932
// silently reconnect without replaying attach and confirm.
19001933
if abort.is_aborted() || abort.connected.swap(true, Ordering::AcqRel) {
19011934
return Err(AbortableTransport::aborted_error());
19021935
}
1903-
connect_boundary_with_retry(&runtime_descriptor)
1936+
connect_boundary_with_retry(&runtime_descriptor, connector.clone())
19041937
.await
19051938
.map(|inner| TokioIo::new(AbortableTransport { inner, abort }))
19061939
.map_err(|error| std::io::Error::other(error.to_string()))
@@ -1921,52 +1954,65 @@ impl BoundaryClient {
19211954

19221955
async fn connect_boundary_with_retry(
19231956
runtime_descriptor: &SandboxRuntimeDescriptor,
1957+
connector: Option<Arc<dyn BoundaryTransportConnector>>,
19241958
) -> Result<BoundaryDuplexStream, BackendError> {
19251959
let deadline = tokio::time::Instant::now() + CONNECT_RETRY_TIMEOUT;
19261960
loop {
1927-
match connect_boundary_once(runtime_descriptor).await {
1961+
match connect_boundary_using_connector(runtime_descriptor, connector.as_deref()).await {
19281962
Ok(stream) => return Ok(stream),
19291963
Err(error) if tokio::time::Instant::now() >= deadline => return Err(error),
19301964
Err(_) => tokio::time::sleep(Duration::from_millis(25)).await,
19311965
}
19321966
}
19331967
}
19341968

1969+
#[cfg(test)]
19351970
async fn connect_boundary_once(
19361971
runtime_descriptor: &SandboxRuntimeDescriptor,
19371972
) -> Result<BoundaryDuplexStream, BackendError> {
1938-
let stream: BoundaryDuplexStream = match &runtime_descriptor.transport {
1939-
#[cfg(unix)]
1940-
SandboxTransport::Unix { socket_path } => {
1941-
let stream = UnixStream::connect(socket_path).await.map_err(|error| {
1942-
BackendError::Unavailable(format!(
1943-
"connect to mapped boundary control socket {}: {error}",
1944-
socket_path.display()
1945-
))
1946-
})?;
1947-
Box::new(stream)
1948-
}
1949-
#[cfg(not(unix))]
1950-
SandboxTransport::Unix { .. } => {
1951-
return Err(BackendError::Unavailable(
1952-
"Unix boundary transport requires a Unix host".to_string(),
1953-
));
1954-
}
1955-
SandboxTransport::Tcp {
1956-
authority,
1957-
addresses,
1958-
} => {
1959-
let stream = openshell_core::net::connect_tcp_nodelay_best_effort(addresses)
1960-
.await
1961-
.map_err(|error| {
1973+
connect_boundary_using_connector(runtime_descriptor, None).await
1974+
}
1975+
1976+
async fn connect_boundary_using_connector(
1977+
runtime_descriptor: &SandboxRuntimeDescriptor,
1978+
connector: Option<&dyn BoundaryTransportConnector>,
1979+
) -> Result<BoundaryDuplexStream, BackendError> {
1980+
let stream: BoundaryDuplexStream = if let Some(connector) = connector {
1981+
connector.connect(runtime_descriptor).await?
1982+
} else {
1983+
match &runtime_descriptor.transport {
1984+
#[cfg(unix)]
1985+
SandboxTransport::Unix { socket_path } => {
1986+
let stream = UnixStream::connect(socket_path).await.map_err(|error| {
19621987
BackendError::Unavailable(format!(
1963-
"connect to boundary TLS endpoint {authority}: {error}"
1988+
"connect to mapped boundary control socket {}: {error}",
1989+
socket_path.display()
19641990
))
19651991
})?;
1966-
enable_boundary_tcp_keepalive(&stream);
1967-
Box::new(stream)
1992+
Box::new(stream)
1993+
}
1994+
#[cfg(not(unix))]
1995+
SandboxTransport::Unix { .. } => {
1996+
return Err(BackendError::Unavailable(
1997+
"Unix boundary transport requires a Unix host".to_string(),
1998+
));
1999+
}
2000+
SandboxTransport::Tcp {
2001+
authority,
2002+
addresses,
2003+
} => {
2004+
let stream = openshell_core::net::connect_tcp_nodelay_best_effort(addresses)
2005+
.await
2006+
.map_err(|error| {
2007+
BackendError::Unavailable(format!(
2008+
"connect to boundary TLS endpoint {authority}: {error}"
2009+
))
2010+
})?;
2011+
enable_boundary_tcp_keepalive(&stream);
2012+
Box::new(stream)
2013+
}
2014+
SandboxTransport::Vsock { guest_cid, port } => connect_host_vsock(*guest_cid, *port)?,
19682015
}
1969-
SandboxTransport::Vsock { guest_cid, port } => connect_host_vsock(*guest_cid, *port)?,
19702016
};
19712017
let tls = &runtime_descriptor.tls;
19722018
let server_name =
@@ -3165,6 +3211,83 @@ mod tests {
31653211
server.abort();
31663212
}
31673213

3214+
#[derive(Debug)]
3215+
struct ReverseTestConnector(tokio::net::TcpListener);
3216+
3217+
#[async_trait]
3218+
impl BoundaryTransportConnector for ReverseTestConnector {
3219+
async fn connect(
3220+
&self,
3221+
_: &SandboxRuntimeDescriptor,
3222+
) -> Result<BoundaryDuplexStream, BackendError> {
3223+
let (stream, _) = self
3224+
.0
3225+
.accept()
3226+
.await
3227+
.map_err(|error| BackendError::Unavailable(error.to_string()))?;
3228+
Ok(Box::new(stream))
3229+
}
3230+
}
3231+
3232+
#[tokio::test]
3233+
async fn custom_reverse_transport_preserves_tls_and_bearer_authentication() {
3234+
let certificate = test_certificate();
3235+
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
3236+
let address = listener.local_addr().unwrap();
3237+
let connector = Arc::new(ReverseTestConnector(listener));
3238+
let server = tokio::spawn(async move {
3239+
let stream = tokio::net::TcpStream::connect(address).await.unwrap();
3240+
let stream = tokio_rustls::TlsAcceptor::from(certificate.server_config)
3241+
.accept(stream)
3242+
.await
3243+
.unwrap();
3244+
serve_test_grpc(Box::new(stream), "a".repeat(32)).await;
3245+
});
3246+
let mut client = BoundaryClient::new(
3247+
tls_runtime_descriptor(address, certificate.client_tls),
3248+
test_bearer(&"a".repeat(32)),
3249+
);
3250+
client.connector = Some(connector);
3251+
let response =
3252+
tokio::time::timeout(Duration::from_secs(5), client.exchange(Request::Confirm))
3253+
.await
3254+
.unwrap()
3255+
.unwrap();
3256+
assert_eq!(
3257+
response,
3258+
Response::Confirmed {
3259+
confirmation: Box::new(test_confirmation())
3260+
}
3261+
);
3262+
server.abort();
3263+
}
3264+
3265+
#[tokio::test]
3266+
async fn custom_transport_cannot_bypass_tls_peer_verification() {
3267+
let server_certificate = test_certificate();
3268+
let different_trust = test_certificate();
3269+
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
3270+
let address = listener.local_addr().unwrap();
3271+
let connector = ReverseTestConnector(listener);
3272+
let server = tokio::spawn(async move {
3273+
let stream = tokio::net::TcpStream::connect(address).await.unwrap();
3274+
let _ = tokio_rustls::TlsAcceptor::from(server_certificate.server_config)
3275+
.accept(stream)
3276+
.await;
3277+
});
3278+
let descriptor = tls_runtime_descriptor(address, different_trust.client_tls);
3279+
assert!(
3280+
tokio::time::timeout(
3281+
Duration::from_secs(5),
3282+
connect_boundary_using_connector(&descriptor, Some(&connector))
3283+
)
3284+
.await
3285+
.unwrap()
3286+
.is_err()
3287+
);
3288+
server.await.unwrap();
3289+
}
3290+
31683291
#[tokio::test]
31693292
async fn tls_tcp_rejects_tls12_only_server() {
31703293
let certificate = test_certificate_with_protocol_versions(&[&rustls::version::TLS12]);

‎crates/openshell-supervisor-process/Cargo.toml‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,6 @@ base64 = { workspace = true }
2121
bytes = { workspace = true }
2222
hex = "0.4"
2323
miette = { workspace = true }
24-
nix = { workspace = true }
2524
rand = "0.10"
2625
russh = "0.63.1"
2726
serde_json = { workspace = true }

0 commit comments

Comments
 (0)