@@ -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 ) ]
7585pub 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
10981127struct 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
19221955async 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) ]
19351970async 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 ] ) ;
0 commit comments