From 3a7c3be60ccc0c4cebec7747c7c42d53f84fd58d Mon Sep 17 00:00:00 2001 From: Kris Hicks Date: Fri, 13 Nov 2026 07:17:25 -0800 Subject: [PATCH] feat(audit): name exec, forward, and SSH session resources Exec, ForwardTcp, and SSH session records named no resources, so a reader could not tie a record to the sandbox, relay channel, or session it acted on, or tell which revoke ended a session. Name the sandbox and the relay channel each exec or forward opens; an exec's channel matches the channel_id in the gateway's sandbox logs. Record a TCP forward's target host and port, and name SSH sessions, and the SSH forwards that use them, by their generated name. A repeated revoke records no_op:already_absent. Add [openshell.gateway.audit] capture_exec_command to record exec command arguments. Environment variables, standard input, and session tokens are never recorded. Signed-off-by: Kris Hicks --- crates/openshell-core/src/config.rs | 5 + crates/openshell-server/src/config_file.rs | 9 +- crates/openshell-server/src/grpc/mod.rs | 20 +- .../src/grpc/mutation_audit.rs | 490 +++++++++++++++++- crates/openshell-server/src/grpc/sandbox.rs | 17 +- docs/how-it-works/gateways/configuration.mdx | 3 + docs/observability/ocsf-json-export.mdx | 4 +- 7 files changed, 533 insertions(+), 15 deletions(-) diff --git a/crates/openshell-core/src/config.rs b/crates/openshell-core/src/config.rs index 135b88a958..9864cb921d 100644 --- a/crates/openshell-core/src/config.rs +++ b/crates/openshell-core/src/config.rs @@ -725,6 +725,11 @@ pub struct GatewayAuditConfig { /// sets. Bytes values are never recorded. #[serde(default)] pub capture_setting_values: bool, + /// Record the command arguments of `ExecSandbox` and + /// `ExecSandboxInteractive` calls. Environment variables and standard + /// input are never recorded. + #[serde(default)] + pub capture_exec_command: bool, } /// mTLS user authentication for gateway users. diff --git a/crates/openshell-server/src/config_file.rs b/crates/openshell-server/src/config_file.rs index f4bff4e943..53acb39e3e 100644 --- a/crates/openshell-server/src/config_file.rs +++ b/crates/openshell-server/src/config_file.rs @@ -2129,10 +2129,15 @@ service_name = "openshell-gateway-dev" #[test] fn gateway_audit_capture_is_opt_in() { - let tmp = write_tmp("[openshell.gateway.audit]\ncapture_setting_values = true\n"); + let tmp = write_tmp( + "[openshell.gateway.audit]\ncapture_setting_values = true\ncapture_exec_command = true\n", + ); let audit = load(tmp.path()).unwrap().openshell.gateway.audit.unwrap(); assert!(audit.capture_setting_values); - assert!(!GatewayAuditConfig::default().capture_setting_values); + assert!(audit.capture_exec_command); + let defaults = GatewayAuditConfig::default(); + assert!(!defaults.capture_setting_values); + assert!(!defaults.capture_exec_command); } #[test] diff --git a/crates/openshell-server/src/grpc/mod.rs b/crates/openshell-server/src/grpc/mod.rs index 69c1d30288..2918f7772b 100644 --- a/crates/openshell-server/src/grpc/mod.rs +++ b/crates/openshell-server/src/grpc/mod.rs @@ -591,6 +591,7 @@ impl OpenShell for OpenShellService { &self, request: Request, ) -> Result, Status> { + mutation_audit::record_exec_targets(request.get_ref()); mutation_replay::run(&self.state, request).await } @@ -619,7 +620,18 @@ impl OpenShell for OpenShellService { &self, request: Request, ) -> Result, Status> { - sandbox::handle_create_ssh_session(&self.state, request).await + let targets = { + let request = request.get_ref(); + mutation_audit::scoped( + request.workspace_scope.as_ref(), + [mutation_audit::requested("sandbox", &request.sandbox)], + ) + }; + mutation_audit::audited( + targets, + sandbox::handle_create_ssh_session(&self.state, request), + ) + .await } async fn expose_service( @@ -674,7 +686,11 @@ impl OpenShell for OpenShellService { &self, request: Request, ) -> Result, Status> { - sandbox::handle_revoke_ssh_session(&self.state, request).await + mutation_audit::audited( + Vec::new(), + sandbox::handle_revoke_ssh_session(&self.state, request), + ) + .await } // --- Providers --- diff --git a/crates/openshell-server/src/grpc/mutation_audit.rs b/crates/openshell-server/src/grpc/mutation_audit.rs index 6f51302b3f..80c7096e12 100644 --- a/crates/openshell-server/src/grpc/mutation_audit.rs +++ b/crates/openshell-server/src/grpc/mutation_audit.rs @@ -20,7 +20,12 @@ use openshell_core::proto::{ UpdateConfigResponse, UpdateProviderProfilesResponse, WorkspaceSelector, setting_value, workspace_selector::Selection, }; +use openshell_core::proto::{ + CreateSshSessionResponse, ExecSandboxRequest, RevokeSshSessionResponse, SshSession, + TcpForwardInit, relay_open, +}; use openshell_core::settings::{self, SettingValueKind}; +use openshell_core::{GatewayAuditConfig, ObjectName, ObjectWorkspace}; use openshell_ocsf::ResourceDetails; use tonic::{Code, Response, Status}; @@ -75,6 +80,7 @@ deletion!( DeleteProviderRefreshResponse, DeleteWorkspaceResponse, RemoveWorkspaceMemberResponse, + RevokeSshSessionResponse, ); impl Audited for DeleteSandboxResponse { @@ -298,6 +304,16 @@ impl Audited for ClearDraftChunksResponse { } } +impl Audited for CreateSshSessionResponse { + fn produced(&self) -> Vec> { + vec![Produced { + type_label: "sandbox", + name: "", + uid: &self.sandbox_id, + }] + } +} + impl Audited for RejectDraftChunkResponse {} impl Audited for EditDraftChunkResponse {} @@ -380,16 +396,17 @@ pub(super) async fn record_absent_delete( /// Run `call`, recording the requested `targets` that have a name before it /// starts, then what it produced and how it ended. The call is boxed because /// handler futures are large. +/// +/// Hooks record targets here when the unary request names them. Handlers +/// record the rest: what exists only once admitted, such as a relay channel +/// or a stored session, and the targets of client-streaming requests. pub(super) fn audited( - mut targets: Vec, + targets: Vec, call: impl Future, Status>>, ) -> impl Future, Status>> { let call = Box::pin(call); async move { - targets.retain(|target| target.name.as_deref().is_some_and(|name| !name.is_empty())); - for target in targets { - audit::record_target(target); - } + record_requested(targets); let response = call.await; if let Ok(response) = &response { let response = response.get_ref(); @@ -403,6 +420,118 @@ pub(super) fn audited( } } +/// Record each requested target that has a non-empty name. +fn record_requested(targets: impl IntoIterator) { + for target in targets { + if target.name.as_deref().is_some_and(|name| !name.is_empty()) { + audit::record_target(target); + } + } +} + +/// Command arguments an exec record holds at most. +const MAX_EXEC_ARGS: usize = 32; + +/// Record the workspace and sandbox an exec requested, before it starts. +pub(super) fn record_exec_targets(request: &ExecSandboxRequest) { + record_requested(scoped( + request.workspace_scope.as_ref(), + [requested("sandbox", &request.sandbox)], + )); +} + +/// Record the relay an exec opened, with its command when `config` captures it. +pub(super) fn record_exec_relay( + config: &GatewayAuditConfig, + sandbox: &Sandbox, + channel_id: &str, + request: &ExecSandboxRequest, +) { + let data = exec_command(config.capture_exec_command, request); + record_relay("exec", sandbox, channel_id, data); +} + +/// Resource data holding an exec's first `MAX_EXEC_ARGS` command arguments +/// and how many it left out, when `capture` is set. +fn exec_command(capture: bool, request: &ExecSandboxRequest) -> Option { + capture.then(|| { + let command: Vec<&String> = request.command.iter().take(MAX_EXEC_ARGS).collect(); + let omitted = request.command.len() - command.len(); + if omitted == 0 { + serde_json::json!({ "command": command }) + } else { + serde_json::json!({ "command": command, "omitted": omitted }) + } + }) +} + +/// Record the workspace and sandbox a forward requested, before it starts. +/// `TcpForwardInit` names its workspace directly. +pub(super) fn record_forward_targets(init: &TcpForwardInit) { + record_requested([ + requested("workspace", &init.workspace), + requested("sandbox", &init.sandbox), + ]); +} + +/// Record the relay a forward opened to `target`. A TCP forward's data holds +/// its host and port. +pub(super) fn record_forward_relay( + sandbox: &Sandbox, + channel_id: &str, + target: &relay_open::Target, +) { + let data = match target { + relay_open::Target::Tcp(target) => { + Some(serde_json::json!({ "host": target.host, "port": target.port })) + } + relay_open::Target::Ssh(_) => None, + }; + record_relay("forward", sandbox, channel_id, data); +} + +/// Record the relay opened to `sandbox` as a `type_label` resource whose +/// `uid` is its channel ID. +fn record_relay( + type_label: &str, + sandbox: &Sandbox, + channel_id: &str, + data: Option, +) { + let produced = stored_sandbox(Some(sandbox)); + audit::amend_targets(|targets| { + complete(targets, produced); + targets.push(ResourceDetails { + uid: Some(channel_id.to_string()), + name: None, + type_label: Some(type_label.to_string()), + data, + }); + }); +} + +/// Record an SSH session by its name, never by its ID, which is its token. +pub(super) fn record_ssh_session(name: &str) { + record_requested([requested("ssh_session", name)]); +} + +/// Record the session a revoke found: its workspace, sandbox, and name. +pub(super) fn record_revoked_ssh_session(session: &SshSession) { + record_requested([requested("workspace", session.object_workspace())]); + audit::record_target(ResourceDetails { + uid: Some(session.sandbox_id.clone()), + name: None, + type_label: Some("sandbox".to_string()), + data: None, + }); + record_ssh_session(session.object_name()); +} + +/// Record a revoke of a session that was already revoked as a no-op. +pub(super) fn record_repeated_revoke() { + audit::record_outcome(Outcome::Detail("no_op:already_absent")); +} + /// Fill in the first unfilled requested target of each produced /// resource's type, or add the resource. fn complete(targets: &mut Vec, produced: Vec>) { @@ -477,6 +606,11 @@ mod tests { RotateProviderCredentialRequest, SandboxPolicy, SettingValue, UndoDraftChunkRequest, UpdateConfigRequest, UpdateProviderRequest, setting_value, }; + use openshell_core::proto::{ + CreateSshSessionRequest, ExecSandboxInput, ExecSandboxRequest, RevokeSshSessionRequest, + SshRelayTarget, TcpForwardFrame, TcpForwardInit, TcpRelayTarget, tcp_forward_frame, + tcp_forward_init, + }; use serde_json::{Value, json}; use std::collections::HashMap; use std::sync::Arc; @@ -1835,4 +1969,350 @@ mod tests { assert_eq!(named(&event), ["provider:audit-openai"]); assert_redacted(&event, CANARY); } + + /// Decodes the frames `client_stream` sends. + struct Decode(std::marker::PhantomData); + + impl tonic::codec::Decoder for Decode { + type Item = T; + type Error = Status; + + fn decode(&mut self, buf: &mut tonic::codec::DecodeBuf<'_>) -> Result, Status> { + T::decode(buf) + .map(Some) + .map_err(|error| Status::internal(error.to_string())) + } + } + + /// A client stream that sends `frames` and ends. + fn client_stream( + frames: &[T], + ) -> tonic::Streaming { + let mut body = Vec::new(); + for frame in frames { + let frame = frame.encode_to_vec(); + body.push(0); + body.extend(u32::try_from(frame.len()).unwrap().to_be_bytes()); + body.extend(frame); + } + tonic::Streaming::new_request( + Decode(std::marker::PhantomData), + http_body_util::Full::new(bytes::Bytes::from(body)), + None, + None, + ) + } + + /// A ready sandbox named `agent-01` whose supervisor session hands each + /// relay it is asked to open to the returned receiver. + async fn ready_sandbox( + state: &Arc, + ) -> tokio::sync::mpsc::Receiver { + let mut sandbox = Sandbox { + metadata: Some(ObjectMeta { + id: "sb-agent-01".into(), + name: "agent-01".into(), + workspace: "default".into(), + ..Default::default() + }), + ..Default::default() + }; + sandbox.set_phase(openshell_core::proto::SandboxPhase::Ready as i32); + state.store.put_message(&sandbox).await.unwrap(); + let (tx, rx) = tokio::sync::mpsc::channel(8); + state.supervisor_sessions.register( + "sb-agent-01".into(), + "session-1".into(), + tx, + tokio::sync::oneshot::channel().0, + ); + rx + } + + /// The channel of the next relay the supervisor was asked to open. + fn relay_channel( + supervisor: &mut tokio::sync::mpsc::Receiver, + ) -> String { + use openshell_core::proto::gateway_message::Payload; + loop { + if let Some(Payload::RelayOpen(open)) = supervisor.try_recv().unwrap().payload { + return open.channel_id; + } + } + } + + fn exec_request() -> ExecSandboxRequest { + ExecSandboxRequest { + workspace_scope: Some(workspace_selector("default")), + sandbox: "agent-01".into(), + command: vec!["echo".into(), format!("{CANARY}-command")], + environment: HashMap::from([("API_TOKEN".into(), format!("{CANARY}-env"))]), + stdin: format!("{CANARY}-stdin").into_bytes(), + ..Default::default() + } + } + + /// An interactive exec that starts and then sends input. + fn interactive_exec() -> tonic::Streaming { + use openshell_core::proto::exec_sandbox_input::Payload; + client_stream(&[ + ExecSandboxInput { + payload: Some(Payload::Start(exec_request())), + }, + ExecSandboxInput { + payload: Some(Payload::Stdin(format!("{CANARY}-input").into_bytes())), + }, + ]) + } + + fn agent_sandbox() -> Value { + json!({"type": "sandbox", "name": "agent-01", "uid": "sb-agent-01"}) + } + + #[tokio::test] + async fn execs_name_the_sandbox_and_relay_but_not_their_command_env_or_stdin_by_default() { + let state = test_server_state().await; + let mut supervisor = ready_sandbox(&state).await; + let service = OpenShellService::new(state); + + let (result, event) = record( + "ExecSandbox", + service.exec_sandbox(authed_request(exec_request())), + ) + .await; + + result.unwrap(); + assert_eq!( + event["resources"], + json!([ + default_workspace(), + agent_sandbox(), + {"type": "exec", "uid": relay_channel(&mut supervisor)}, + ]), + "{event}" + ); + assert_redacted(&event, CANARY); + + let (result, event) = record( + "ExecSandboxInteractive", + service.exec_sandbox_interactive(authed_request(interactive_exec())), + ) + .await; + + result.unwrap(); + assert_eq!( + event["resources"], + json!([ + default_workspace(), + agent_sandbox(), + {"type": "exec", "uid": relay_channel(&mut supervisor)}, + ]), + "{event}" + ); + assert_redacted(&event, CANARY); + } + + #[tokio::test] + async fn execs_record_their_command_when_the_gateway_captures_it() { + let mut state = test_server_state().await; + Arc::get_mut(&mut state) + .expect("unshared test state") + .config + .audit + .capture_exec_command = true; + let mut supervisor = ready_sandbox(&state).await; + let service = OpenShellService::new(state); + + let (result, event) = record( + "ExecSandbox", + service.exec_sandbox(authed_request(exec_request())), + ) + .await; + + result.unwrap(); + assert_eq!( + event["resources"][2], + json!({ + "type": "exec", + "uid": relay_channel(&mut supervisor), + "data": {"command": ["echo", format!("{CANARY}-command")]}, + }), + "{event}" + ); + for secret in [format!("{CANARY}-env"), format!("{CANARY}-stdin")] { + assert_redacted(&event, &secret); + } + } + + #[test] + fn captured_commands_count_the_arguments_left_out() { + let request = ExecSandboxRequest { + command: (0..40).map(|n| n.to_string()).collect(), + ..Default::default() + }; + + let data = exec_command(true, &request).unwrap(); + + assert_eq!(data["command"].as_array().unwrap().len(), 32); + assert_eq!(data["command"][31], "31"); + assert_eq!(data["omitted"], 8); + } + + #[tokio::test] + async fn rejected_exec_names_the_requested_sandbox() { + let service = OpenShellService::new(test_server_state().await); + + let (_, event) = record( + "ExecSandboxInteractive", + service.exec_sandbox_interactive(authed_request(interactive_exec())), + ) + .await; + + assert_eq!(event["status_detail"], "rejected:not_found", "{event}"); + assert_eq!(named(&event), ["workspace:default", "sandbox:agent-01"]); + assert_redacted(&event, CANARY); + } + + #[tokio::test] + async fn ssh_session_and_forward_records_name_the_session_but_never_its_token() { + let state = test_server_state().await; + let mut supervisor = ready_sandbox(&state).await; + let service = OpenShellService::new(state); + + let (result, created) = record( + "CreateSshSession", + service.create_ssh_session(authed_request(CreateSshSessionRequest { + workspace_scope: Some(workspace_selector("default")), + sandbox: "agent-01".into(), + })), + ) + .await; + let token = result.unwrap().into_inner().token; + let session = created["resources"][2]["name"] + .as_str() + .unwrap() + .to_string(); + let ssh_session = json!({"type": "ssh_session", "name": session}); + assert_eq!( + created["resources"], + json!([default_workspace(), agent_sandbox(), ssh_session]), + "{created}" + ); + assert_redacted(&created, &token); + + let forward = client_stream(&[ + TcpForwardFrame { + payload: Some(tcp_forward_frame::Payload::Init(TcpForwardInit { + sandbox: "agent-01".into(), + workspace: "default".into(), + target: Some(tcp_forward_init::Target::Ssh(SshRelayTarget {})), + authorization_token: token.clone(), + ..Default::default() + })), + }, + TcpForwardFrame { + payload: Some(tcp_forward_frame::Payload::Data(CANARY.into())), + }, + ]); + let (result, forwarded) = + record("ForwardTcp", service.forward_tcp(authed_request(forward))).await; + result.unwrap(); + assert_eq!( + forwarded["resources"], + json!([ + default_workspace(), + agent_sandbox(), + ssh_session, + {"type": "forward", "uid": relay_channel(&mut supervisor)}, + ]), + "{forwarded}" + ); + assert_redacted(&forwarded, &token); + assert_redacted(&forwarded, CANARY); + + let revoke = || { + service.revoke_ssh_session(authed_request(RevokeSshSessionRequest { + token: token.clone(), + allow_missing: false, + })) + }; + let (_, revoked) = record("RevokeSshSession", revoke()).await; + assert_eq!( + revoked["resources"], + json!([ + default_workspace(), + {"type": "sandbox", "uid": "sb-agent-01"}, + ssh_session, + ]), + "{revoked}" + ); + assert!(revoked.get("status_detail").is_none(), "{revoked}"); + assert_redacted(&revoked, &token); + + let (_, repeated) = record("RevokeSshSession", revoke()).await; + assert_eq!( + repeated["status_detail"], "no_op:already_absent", + "{repeated}" + ); + assert_eq!(repeated["resources"], revoked["resources"]); + } + + #[tokio::test] + async fn revoking_an_unknown_ssh_session_names_nothing() { + let service = OpenShellService::new(test_server_state().await); + let revoke = |allow_missing| { + service.revoke_ssh_session(authed_request(RevokeSshSessionRequest { + token: CANARY.into(), + allow_missing, + })) + }; + + let (_, absent) = record("RevokeSshSession", revoke(true)).await; + let (_, rejected) = record("RevokeSshSession", revoke(false)).await; + + assert_eq!(absent["status_detail"], "no_op:already_absent", "{absent}"); + assert_eq!( + rejected["status_detail"], "rejected:not_found", + "{rejected}" + ); + for event in [absent, rejected] { + assert!(event.get("resources").is_none(), "{event}"); + assert_redacted(&event, CANARY); + } + } + + #[tokio::test] + async fn tcp_forwards_record_their_target() { + let state = test_server_state().await; + let mut supervisor = ready_sandbox(&state).await; + let service = OpenShellService::new(state); + let init = TcpForwardFrame { + payload: Some(tcp_forward_frame::Payload::Init(TcpForwardInit { + sandbox: "agent-01".into(), + workspace: "default".into(), + target: Some(tcp_forward_init::Target::Tcp(TcpRelayTarget { + host: "127.0.0.1".into(), + port: 8080, + })), + ..Default::default() + })), + }; + + let (result, event) = record( + "ForwardTcp", + service.forward_tcp(authed_request(client_stream(&[init]))), + ) + .await; + + result.unwrap(); + assert_eq!( + event["resources"][2], + json!({ + "type": "forward", + "uid": relay_channel(&mut supervisor), + "data": {"host": "127.0.0.1", "port": 8080}, + }), + "{event}" + ); + } } diff --git a/crates/openshell-server/src/grpc/sandbox.rs b/crates/openshell-server/src/grpc/sandbox.rs index 46112edaf8..77c63275e8 100644 --- a/crates/openshell-server/src/grpc/sandbox.rs +++ b/crates/openshell-server/src/grpc/sandbox.rs @@ -2762,6 +2762,7 @@ pub(super) async fn handle_exec_sandbox( ) .await .map_err(|e| Status::unavailable(format!("supervisor relay failed: {e}")))?; + super::mutation_audit::record_exec_relay(&state.config.audit, &sandbox, &channel_id, &req); let command_str = build_remote_exec_command(&req) .map_err(|e| Status::invalid_argument(format!("command construction failed: {e}")))?; @@ -2868,6 +2869,7 @@ pub(super) async fn handle_forward_tcp( )); }; + super::mutation_audit::record_forward_targets(&init); let target = validate_tcp_forward_init(&init)?; let sandbox = resolve_and_authorize_sandbox_name( @@ -2891,12 +2893,13 @@ pub(super) async fn handle_forward_tcp( let (channel_id, relay_rx) = crate::supervisor_session::open_routed_relay_with_target( state, sandbox.object_id(), - target, + target.clone(), init.service_id.clone(), std::time::Duration::from_secs(15), ) .await .map_err(|e| Status::unavailable(format!("supervisor relay failed: {e}")))?; + super::mutation_audit::record_forward_relay(&sandbox, &channel_id, &target); let (tx, rx) = mpsc::channel::>(256); let sandbox_id = sandbox.object_id().to_string(); @@ -3010,9 +3013,10 @@ async fn acquire_forward_connection_guard( }); } - validate_ssh_forward_token(state, token, &sandbox_id) + let session = validate_ssh_forward_token(state, token, &sandbox_id) .await .map_err(|rejection| crate::auth::audit::reject_credential(Some(principal), rejection))?; + super::mutation_audit::record_ssh_session(session.object_name()); crate::auth::audit::emit_ssh_session_logon(&state.logons, principal, token); acquire_ssh_connection_slots(state, budget, token, &sandbox_id)?; @@ -3029,7 +3033,7 @@ async fn validate_ssh_forward_token( state: &Arc, token: &str, sandbox_id: &str, -) -> Result<(), AuthRejection> { +) -> Result { let reject = |reason, status| AuthRejection::new(AuthMechanism::SshSessionToken, reason, status); let session = state @@ -3079,7 +3083,7 @@ async fn validate_ssh_forward_token( } } - Ok(()) + Ok(session) } const MAX_CONNECTIONS_PER_TOKEN: u32 = 3; @@ -3308,6 +3312,7 @@ pub(super) async fn handle_exec_sandbox_interactive( .map_err(|e| Status::internal(format!("failed to read first message: {e}")))?; let req = validate_interactive_exec_start(first_msg)?; + super::mutation_audit::record_exec_targets(&req); let mut request = Request::from_parts( metadata, @@ -3373,6 +3378,7 @@ pub(super) async fn handle_exec_sandbox_interactive_start( ) .await .map_err(|e| Status::unavailable(format!("supervisor relay failed: {e}")))?; + super::mutation_audit::record_exec_relay(&state.config.audit, &sandbox, &channel_id, req); let command_str = build_remote_exec_command(req) .map_err(|e| Status::invalid_argument(format!("command construction failed: {e}")))?; @@ -3517,6 +3523,7 @@ pub(super) async fn handle_create_ssh_session( ) .await .map_err(|e| Status::internal(format!("persist ssh session failed: {e}")))?; + super::mutation_audit::record_ssh_session(session.object_name()); let (gateway_host, gateway_port) = resolve_gateway(&state.config); let scheme = if state.config.tls.is_some() { @@ -3559,6 +3566,7 @@ pub(super) async fn handle_revoke_ssh_session( outcome: super::deletion_outcome(false, req.allow_missing, "ssh session")?, })); }; + super::mutation_audit::record_revoked_ssh_session(&session); authorize_sandbox_workspace( &state.store, &state.admin_role, @@ -3576,6 +3584,7 @@ pub(super) async fn handle_revoke_ssh_session( })?; if session.revoked { + super::mutation_audit::record_repeated_revoke(); return Ok(Response::new(RevokeSshSessionResponse { outcome: openshell_core::proto::DeletionOutcome::Completed.into(), })); diff --git a/docs/how-it-works/gateways/configuration.mdx b/docs/how-it-works/gateways/configuration.mdx index 60f2d404d2..0aebebd623 100644 --- a/docs/how-it-works/gateways/configuration.mdx +++ b/docs/how-it-works/gateways/configuration.mdx @@ -437,6 +437,7 @@ operator_enabled = false # Opt-in: trusted OU=operator grants gateway-wide admin [openshell.gateway.audit] capture_setting_values = false # Opt-in: record setting values in mutation records. +capture_exec_command = false # Opt-in: record exec command arguments in mutation records. # OTLP export. Omit this table entirely to disable it. [openshell.gateway.otlp] @@ -807,11 +808,13 @@ Allow enough retention and disk space for shipper outages. Graceful shutdown all ```toml [openshell.gateway.audit] capture_setting_values = true +capture_exec_command = true ``` | Field | Default | Behavior | |---|---|---| | `capture_setting_values` | `false` | Record the value an `UpdateConfig` call sets for a registered setting. | +| `capture_exec_command` | `false` | Record the first 32 arguments of each exec command. Arguments can contain secrets the caller passes, such as an `Authorization` header. | Unknown fields are rejected. Restart the gateway after changing this configuration. diff --git a/docs/observability/ocsf-json-export.mdx b/docs/observability/ocsf-json-export.mdx index 2d89f728c8..48047e68b8 100644 --- a/docs/observability/ocsf-json-export.mdx +++ b/docs/observability/ocsf-json-export.mdx @@ -64,9 +64,9 @@ The gateway also emits an API Activity event for each call a user or mTLS operat `status_detail` qualifies the outcome: `no_op:` when a successful call changed nothing, `rejected:` (Low) or `error:` (Medium) with the gRPC code when it failed, and `unknown:cancelled` (Medium) when the client disconnected before the call finished, which may still have applied the change. -`resources` names the workspace and the resources the call acted on. +`resources` names the workspace and the resources the call acted on. An exec's `exec` resource has as its `uid` the `channel_id` from the exec's `command started` line in the gateway's sandbox logs, so you can match the record to the command's log lines. -Records never include credentials, tokens, environment variables, or standard input. Setting values appear only when [enabled](/how-it-works/gateways/configuration#gateway-mutation-records). +Records never include credentials, tokens, environment variables, or standard input. Setting values and exec command arguments appear only when [enabled](/how-it-works/gateways/configuration#gateway-mutation-records). Without JSONL enabled, gateway OCSF events still appear as shorthand in console output, subject to the diagnostic log filter. Events associated with a sandbox also appear in its gateway log stream; gateway-wide events have no sandbox association.