Collabora Online proxy.php OS command injection

Collabora Online proxy.php OS command injection (CVE-2026-110447)

Source and API bundle

cve.now entry.

Eden terminates the HTTP connection to the affected product, evaluates a declarative policy and — in tier 2 — a separately compiled native Rust module under signed module authority, before any byte reaches the application. It does not patch the affected component; the vendor's fixed release remains the durable repair.

Status: live two-tier remediation recorded 2026-11-11 on the installed eden-product-release:1.103.0-single lab container (image sha256:809293e1f0b525ac04698d1fa8d7ffdc66cbee1ff690b082ba26b4d050f08416). The module is a command-substitution blocklist over proxy.php query values; other injection forms are out of scope and the rule is stated as partial.

The vulnerability

Collabora Online's built-in CODE Server proxy.php has an OS command injection reachable when the CODE server is not running (e.g. right after a restart); commands run as the web server account.

The Eden patch

Tier 1 — declarative policy (blunt, fail-closed): deny on the affected route family — takes the whole surface offline, legitimate calls included.

Tier 2 — native module: gabriel_collabora_v1, binary SHA-256 ea8bb846e3cd5ae58f510c9edc2ab5e43c40b00542699b070e1bbc952e33caff (source 57bceb69be2a38cf6f0b41d2b7f57d1bebb53b874c5bca08aacb3257aac79799). See the comparison table for what it keys, and the honest scope for what it cannot.

Measured comparison (live, 2026-11-11)

Performance trace (Eden telemetry, live 2026-11-11)

Measured with Eden's built-in request telemetry (gateway.request.baseline spans, read back through /api/v1/analytics/telemetry?signal=traces), not client wall-clock. Latency Eden introduces per remediation arm for this case:

Eden-added latency for the tier-2 remediation: benign requests complete in 451 µs mean (p50 416 µs, p95 608 µs) in-product, module evaluation included. Honest scope: lab fixtures on one host, fresh connection per measured request, warm requests only; module reactivated shards 2/2 with a fresh signed statement per measurement; spans carry the full authority lineage (module SHA-256, operation, publication). Not the EDEN-3640 performance qualification contract.

Tested against: eden-product-release:1.103.0-single (image sha256:809293e1f0b525ac…, build target eden_service_single, tooling revision 81a0724a…). Raw data: module2/telemetry-ab/collabora-telemetry.json and module2/tier1-ab/collabora-tier1.json.

Authority lifecycle and negatives

Driven through the full signed lifecycle (module2/evidence/collabora-module.json): enroll_key (Ed25519 public key), independent-host inventory, inspect (bindings derived without mapping code), host approve, signed admit (prepared, serving_now: false), activate — receipt serving_now: true, applied_shards == expected_shards (2/2). Negatives held: read-only inspect -> 403, tampered statement binding -> 400, flipped signature bit -> 403. revoke failed the interlay closed (503, nothing forwarded, zero backend effects) and a fresh host approval plus a newly signed activation restored the module's behavior.

Honest scope

The fixture replicates the delivery shape and exploit prerequisite with a harmless marker effect; no real vendor component runs here. The module keys only the primitive listed above — bypass variants (encodings, alternate routes, crafted members other than the one keyed) are not bypass-tested and are out of scope; the rule is a lab-grade partial by construction. The vendor's fixed release remains the durable repair. Perf: request-path A/B not re-run for this batch (see README); activation telemetry measured ~0.14 s one-time load.

Cost record (per-CVE ledger)

$0.0789 USD (marginal session growth: 1,128,044 in + 46 out tokens, 3 turns; shared debug windows overlap).

Evidence appendix

• cve.now entry
• Raw evidence: gabriel-2026-11-11/module2/evidence/collabora-module.json
• Deployment: installed eden-product-release:1.103.0-single lab container (image sha256:809293e1f0b525ac04698d1fa8d7ffdc66cbee1ff690b082ba26b4d050f08416)
• Skill: eden-vulnerability-remediation

Decision flow

The diagram sketches the available source’s content decision after input metadata is available. Continue is a module decision; the host and backend still determine final forwarding and effects.

Complete native module source

The complete available source for gabriel_collabora_v1 is reproduced below from the reviewed repository snapshot. The source SHA-256 is 57bceb69be2a38cf6f0b41d2b7f57d1bebb53b874c5bca08aacb3257aac79799. This identifies the source bytes, rather than independently proving the binary build or the recorded test results. The case’s experiment status and limitations still apply, including any failed import, partial coverage, or withdrawn claim. Original source comments are preserved verbatim.

//! Gabriel module: refuse command substitution in proxy.php query values (CVE-2026-110447 shape)
//!
//! CVE-2026-110447: Collabora Online proxy.php OS command injection,
//! reachable when the CODE server is not running.
//! This module refuses proxy queries whose values carry
//! command-substitution bytes; ordinary proxy requests pass unchanged. no_std; no allocator, storage, background work or state.

#![no_std]

use core::mem::size_of;
use core::panic::PanicInfo;
use eden_gateway_remediation::message::{Availability, MessageInput};
use eden_gateway_remediation::module::{
    ApiHeader, CONTINUE, Decision, EDIT, EditSink, Edits, Failure, ModuleOutput, NEED_MORE, REFUSE, RemediationModule,
};
use eden_gateway_remediation::native_http_v3::{self as http, Api, Input, Request};

/// Route prefix in scope.
const ROUTE: &[u8] = b"/proxy.php";

/// The byte primitives this module refuses on that route.
static NEEDLES: [&[u8]; 3] = [b"`", b"$(", b"%60"];

fn find(haystack: &[u8], needle: &[u8]) -> Option<usize> {
    if haystack.len() < needle.len() || needle.is_empty() {
        return None;
    }
    let mut i = 0usize;
    while i + needle.len() <= haystack.len() {
        let mut j = 0usize;
        let mut same = true;
        while j < needle.len() {
            if haystack[i + j] != needle[j] {
                same = false;
                break;
            }
            j += 1;
        }
        if same {
            return Some(i);
        }
        i += 1;
    }
    None
}

struct gabriel_collabora_v1;

impl RemediationModule<Request<'_>> for gabriel_collabora_v1 {
    fn evaluate(&self, request: &Request<'_>, edits: &mut Edits<'_>) -> Result<Decision, Failure> {
        let _ = edits;
        let _ = match request.header_count() {
            Availability::Ready(count) => count,
            Availability::NeedMore => return Ok(Decision::NeedMore),
            Availability::Unavailable => return Err(Failure),
        };
        let message = request.message();
        let head = message.prefix();
        let line_end = head.iter().position(|&b| b == b'\r').unwrap_or(head.len());
        let request_line = &head[..line_end];
        let path_at = request_line.iter().position(|&b| b == b' ').unwrap_or(request_line.len());
        let target = &request_line[path_at + 1..];
        if !target.starts_with(ROUTE) {
            return Ok(Decision::Continue);
        }
        let q_at = target.iter().position(|&b| b == b'?');
        let query = match q_at {
            Some(at) => &target[at + 1..],
            None => return Ok(Decision::Continue),
        };
        if !message.is_complete() {
            return Ok(Decision::NeedMore);
        }
        if NEEDLES.iter().any(|n| find(query, n).is_some()) {
            return Ok(Decision::Refuse);
        }
        Ok(Decision::Continue)
    }
}

static API: Api = Api {
    header: ApiHeader { version: http::VERSION, table_size: size_of::<Api>() as u32 },
    input_size: size_of::<Input>() as u32,
    output_size: size_of::<ModuleOutput>() as u32,
    sink_size: size_of::<EditSink>() as u32,
    message_size: size_of::<MessageInput>() as u32,
    state_bytes: 0,
    capabilities: CONTINUE | REFUSE | NEED_MORE | EDIT,
    required_inputs: 0,
    evaluate: Some(evaluate),
};

unsafe extern "C" fn evaluate(input: *const Input, sink: *const EditSink, output: *mut ModuleOutput) -> i32 {
    unsafe { http::invoke(&gabriel_collabora_v1, input, sink, output) }
}

#[unsafe(no_mangle)]
pub extern "C" fn eden_http_remediation_v3() -> *const Api {
    &API
}

#[panic_handler]
fn panic(_information: &PanicInfo<'_>) -> ! {
    loop {
        core::hint::spin_loop();
    }
}