refactor(supervisor-middleware): simplify service endpoints

Signed-off-by: Piotr Mlocek <pmlocek@nvidia.com>

Author: pimlock

crates/openshell-server/src/config_file.rs

@@ -174,10 +174,7 @@ pub struct MiddlewareServiceFileConfig {
     /// Operator-facing name used for diagnostics.
     pub name: String,
     /// Plaintext gRPC endpoint reachable by the gateway and supervisors.
-    pub endpoint: String,
-    /// Required explicit opt-in to the local-development-only insecure mode.
-    #[serde(default)]
-    pub allow_insecure: bool,
+    pub grpc_endpoint: String,
     /// Operator-owned body limit for every binding exposed by this service.
     pub max_body_bytes: u64,
 }
@@ -186,8 +183,7 @@ impl From<&MiddlewareServiceFileConfig> for SupervisorMiddlewareService {
     fn from(config: &MiddlewareServiceFileConfig) -> Self {
         Self {
             name: config.name.clone(),
-            endpoint: config.endpoint.clone(),
-            allow_insecure: config.allow_insecure,
+            grpc_endpoint: config.grpc_endpoint.clone(),
             max_body_bytes: config.max_body_bytes,
         }
     }
@@ -439,8 +435,7 @@ allow_unauthenticated_users = true
         let toml = r#"
 [[openshell.gateway.middleware]]
 name = "local-guard"
-endpoint = "http://127.0.0.1:50051"
-allow_insecure = true
+grpc_endpoint = "http://127.0.0.1:50051"
 max_body_bytes = 262144
 "#;
         let tmp = write_tmp(toml);
@@ -449,8 +444,7 @@ max_body_bytes = 262144
             file.openshell.gateway.middleware,
             vec![MiddlewareServiceFileConfig {
                 name: "local-guard".into(),
-                endpoint: "http://127.0.0.1:50051".into(),
-                allow_insecure: true,
+                grpc_endpoint: "http://127.0.0.1:50051".into(),
                 max_body_bytes: 262_144,
             }]
         );

crates/openshell-server/src/grpc/policy.rs

@@ -9331,8 +9331,7 @@ mod tests {
         let settings = HashMap::new();
         let service = openshell_core::proto::SupervisorMiddlewareService {
             name: "local-guard".into(),
-            endpoint: "http://127.0.0.1:50051".into(),
-            allow_insecure: true,
+            grpc_endpoint: "http://127.0.0.1:50051".into(),
             max_body_bytes: 1024,
         };
 

crates/openshell-supervisor-middleware/Cargo.toml

@@ -17,7 +17,7 @@ miette = { workspace = true }
 prost-types = { workspace = true }
 regex = { workspace = true }
 tokio = { workspace = true }
-tonic = { workspace = true, features = ["channel", "server"] }
+tonic = { workspace = true, features = ["channel", "server", "tls-native-roots"] }
 
 [dev-dependencies]
 tokio-stream = { workspace = true, features = ["net"] }

crates/openshell-supervisor-middleware/src/lib.rs

@@ -246,15 +246,11 @@ fn validate_registration(registration: &SupervisorMiddlewareService) -> Result<(
             "supervisor middleware registration name cannot be empty"
         ));
     }
-    if !registration.allow_insecure {
-        return Err(miette!(
-            "middleware registration '{}' must set allow_insecure = true; TLS is not supported in V1",
-            registration.name
-        ));
-    }
-    if !registration.endpoint.starts_with("http://") {
+    if !registration.grpc_endpoint.starts_with("http://")
+        && !registration.grpc_endpoint.starts_with("https://")
+    {
         return Err(miette!(
-            "middleware registration '{}' endpoint must use http:// in the local-development-only V1",
+            "middleware registration '{}' grpc_endpoint must use http:// or https://",
             registration.name
         ));
     }
@@ -365,7 +361,7 @@ impl MiddlewareRegistry {
             let service = Arc::new(
                 remote::RemoteMiddlewareService::connect(
                     &registration.name,
-                    &registration.endpoint,
+                    &registration.grpc_endpoint,
                 )
                 .await?,
             );
@@ -1129,8 +1125,7 @@ mod tests {
     fn external_registration(max_body_bytes: u64) -> SupervisorMiddlewareService {
         SupervisorMiddlewareService {
             name: "local-guard-service".into(),
-            endpoint: "http://127.0.0.1:50051".into(),
-            allow_insecure: true,
+            grpc_endpoint: "http://127.0.0.1:50051".into(),
             max_body_bytes,
         }
     }
@@ -1267,11 +1262,23 @@ mod tests {
     }
 
     #[test]
-    fn external_registration_requires_explicit_insecure_opt_in() {
+    fn external_registration_accepts_http_and_https_grpc_endpoints() {
+        for grpc_endpoint in [
+            "http://127.0.0.1:50051",
+            "https://middleware.example.com:443",
+        ] {
+            let mut registration = external_registration(4096);
+            registration.grpc_endpoint = grpc_endpoint.into();
+            validate_registration(&registration).expect("supported gRPC endpoint scheme");
+        }
+    }
+
+    #[test]
+    fn external_registration_rejects_unsupported_grpc_endpoint_scheme() {
         let mut registration = external_registration(4096);
-        registration.allow_insecure = false;
-        let error = validate_registration(&registration).expect_err("opt-in required");
-        assert!(error.to_string().contains("allow_insecure"));
+        registration.grpc_endpoint = "ftp://middleware.example.com".into();
+        let error = validate_registration(&registration).expect_err("unsupported scheme");
+        assert!(error.to_string().contains("http:// or https://"));
     }
 
     #[tokio::test]
@@ -1293,7 +1300,7 @@ mod tests {
         let server_task = tokio::spawn(server);
 
         let mut registration = external_registration(1024);
-        registration.endpoint = format!("http://{address}");
+        registration.grpc_endpoint = format!("http://{address}");
         let registry = MiddlewareRegistry::connect_services(vec![registration.clone()])
             .await
             .expect("connect external middleware");

crates/openshell-supervisor-middleware/src/remote.rs

@@ -10,7 +10,7 @@ use openshell_core::proto::{
     HttpRequestEvaluation, HttpRequestResult, MiddlewareManifest, ValidateConfigRequest,
     ValidateConfigResponse,
 };
-use tonic::transport::{Channel, Endpoint};
+use tonic::transport::{Channel, ClientTlsConfig, Endpoint};
 use tonic::{Request, Response, Status};
 
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(5);
@@ -23,19 +23,30 @@ pub struct RemoteMiddlewareService {
 }
 
 impl RemoteMiddlewareService {
-    pub async fn connect(registration_name: &str, endpoint: &str) -> Result<Self> {
-        let channel = Endpoint::from_shared(endpoint.to_string())
+    pub async fn connect(registration_name: &str, grpc_endpoint: &str) -> Result<Self> {
+        let mut endpoint = Endpoint::from_shared(grpc_endpoint.to_string())
             .into_diagnostic()
             .wrap_err_with(|| {
-                format!("middleware registration '{registration_name}' has an invalid endpoint")
-            })?
+                format!(
+                    "middleware registration '{registration_name}' has an invalid grpc_endpoint"
+                )
+            })?;
+        if grpc_endpoint.starts_with("https://") {
+            endpoint = endpoint
+                .tls_config(ClientTlsConfig::new().with_enabled_roots())
+                .into_diagnostic()
+                .wrap_err_with(|| {
+                    format!("middleware registration '{registration_name}' could not configure TLS")
+                })?;
+        }
+        let channel = endpoint
             .connect_timeout(CONNECT_TIMEOUT)
             .connect()
             .await
             .into_diagnostic()
             .wrap_err_with(|| {
                 format!(
-                    "middleware registration '{registration_name}' could not connect to {endpoint}"
+                    "middleware registration '{registration_name}' could not connect to {grpc_endpoint}"
                 )
             })?;
         Ok(Self {

docs/extensibility/supervisor-middleware.mdx

@@ -41,16 +41,14 @@ Start an operator-run service before starting the gateway, then add a registrati
 ```toml
 [[openshell.gateway.middleware]]
 name = "local-content-guard"
-endpoint = "http://host.openshell.internal:50051"
-allow_insecure = true
+grpc_endpoint = "http://host.openshell.internal:50051"
 max_body_bytes = 262144
 ```
 
 | Field | Description |
 | --- | --- |
 | `name` | Operator-facing registration name used in diagnostics. Policies do not reference this value. |
-| `endpoint` | Service address reachable from both the gateway and sandbox supervisors. |
-| `allow_insecure` | Required acknowledgement for the currently supported plaintext endpoint. |
+| `grpc_endpoint` | Service address reachable from both the gateway and sandbox supervisors. Supports plaintext `http://` and TLS `https://` with platform trust roots. |
 | `max_body_bytes` | Operator limit applied to every binding exposed by the service. |
 
 The gateway connects to every registered service and verifies its capabilities before accepting traffic. Gateway startup fails when a service is unavailable, reports an invalid capability, or exposes a binding ID already owned by another service. Operator-run services cannot claim the reserved `openshell/` namespace.
@@ -135,7 +133,7 @@ See [Logging](/observability/logging) for log access and [OCSF JSON Export](/obs
 - The supported operation and phase are `HttpRequest/pre_credentials`.
 - Selection uses destination host include and exclude patterns.
 - Required middleware cannot cover `tls: skip` endpoints because OpenShell cannot inspect that traffic.
-- Operator-run services currently use explicitly enabled plaintext `http://` endpoints.
-- TLS, service authentication, health checks, and runtime registration are not available.
+- Operator-run services support plaintext `http://` and TLS `https://` endpoints. HTTPS certificates must chain to a CA in the platform trust store.
+- Custom trust roots, client authentication, health checks, and runtime registration are not available.
 
 For a runnable operator workflow, see the [content guard example](https://github.com/NVIDIA/OpenShell/tree/main/examples/supervisor-middleware-content-guard).

docs/reference/gateway-config.mdx

@@ -103,12 +103,11 @@ guest_tls_key           = "/etc/openshell/certs/client-key.pem"
 grpc_rate_limit_requests       = 120
 grpc_rate_limit_window_seconds = 60
 
-# Local-development-only external supervisor middleware. The endpoint must be
-# reachable from both the gateway and sandbox supervisors.
+# Operator-run supervisor middleware. The gRPC endpoint must be reachable from
+# both the gateway and sandbox supervisors.
 [[openshell.gateway.middleware]]
 name = "local-content-guard"
-endpoint = "http://host.openshell.internal:50051"
-allow_insecure = true
+grpc_endpoint = "http://host.openshell.internal:50051"
 max_body_bytes = 262144
 
 # Gateway listener TLS (distinct from the per-driver guest_tls_*).
@@ -155,8 +154,7 @@ Register operator-run supervisor middleware services with one or more `[[openshe
 ```toml
 [[openshell.gateway.middleware]]
 name = "local-content-guard"
-endpoint = "http://host.openshell.internal:50051"
-allow_insecure = true
+grpc_endpoint = "http://host.openshell.internal:50051"
 max_body_bytes = 262144
 ```
 
@@ -166,7 +164,7 @@ The gateway connects to every registered service and validates `Describe` before
 
 `max_body_bytes` is the operator limit for every binding exposed by the service. It must be greater than zero and no larger than each binding's advertised limit. OpenShell rejects an oversized value instead of silently clamping it.
 
-The service endpoint must use plaintext `http://`, and `allow_insecure = true` is required as an explicit acknowledgement that inspected request content is sent without transport encryption or peer authentication. TLS, authentication, health checks, and runtime registration are not supported. The endpoint must be reachable from both the gateway and sandbox supervisors; use `host.openshell.internal` or another shared address when both runtimes resolve it.
+The service `grpc_endpoint` currently supports plaintext `http://` and TLS `https://` using the platform trust store. Custom trust roots, client authentication, health checks, and runtime registration are not currently supported. The endpoint must be reachable from both the gateway and sandbox supervisors; use `host.openshell.internal` or another shared address that can be resolved in both places.
 
 See [Supervisor Middleware](/extensibility/supervisor-middleware) for selection, failure, body-limit, and operational guidance.