Enclave-Gated Level of Detail for Protected Gaussian Scenes

Photorealistic city-scale 3D scenes are increasingly stored as Gaussian splats: millions of small, semi-transparent colored blobs that a GPU sorts and blends into an image. Such a scene is costly to capture and easy to steal. Any app that renders it on a phone or headset has to hand every blob to the GPU in plain form, and anyone who controls the device's operating system can copy the whole file. Large scenes already cope with limited memory through level of detail (LOD): the renderer keeps coarse versions of distant regions and fades in fine versions as the camera approaches. Our proposal is to put that fade-in decision inside a hardware enclave, a small region of the processor that the operating system cannot read or alter. The enclave would hold the decryption keys and decide, frame by frame, which fine blobs to release to the GPU. Under this design, an attacker who dumps GPU memory gets only what the current view needs, not the asset.

The difficulty is that smooth LOD and tight secrecy pull in opposite directions. Fades without visible "popping" (sudden jumps in detail) require releasing fine detail early and keeping overlapping sets alive. Each early release is a leak, and a leak cannot be undone, because the untrusted GPU can keep anything it was shown. The core idea is to make leakage proportional to visual need. During a fade-in, the fine layer is drawn at low opacity, so only its most important blobs are visible. The enclave therefore releases fine blobs in order of importance, in proportion to the current blend weight. We propose to measure the resulting trade-off between popping and leakage, and to test whether on-device enclave gating beats the obvious alternative of having a server gate the stream.

Core Claim

For a fixed budget of released fine-level primitives, a renderer whose release is gated by an enclave and scaled to the blend weight produces measurably less popping than two alternatives. The first releases whole chunks at the start of each fade, as current chunked systems would. The second has a remote server gate the same content over a realistic network, where round-trip delay forces wider prefetch margins or late arrivals. Equivalently, for a fixed popping level, our scheme leaks fewer unique fine primitives and lengthens the time an attacker needs to collect a given fraction of the scene. We do not claim the scene is unextractable. We claim that bulk extraction is bounded per unit time and costs more than recapturing the scene from rendered frames.

Why This Is Not Already Done

Two literatures sit on either side of this gap, and neither touches it. On the graphics side, the continuous-LOD methods handle popping but assume a fully trusted device. CLoD-GS learns a per-blob distance decay of opacity. LODGE streams spatial chunks and linearly ramps opacity between a start and an end distance. Octree-GS and FLoD build coarse-to-fine hierarchies. Their release order is chosen for image quality and memory, never for what an adversary could collect. LapisGS and GoDe supply the progressive, importance-ordered layering we reuse as the release order, but they say nothing about access control.

On the security side, enclave work on edge devices protects neural network weights by splitting computation. DarkneTZ shields final layers. MirrorNet pairs a deliberately weakened public network with a small secret corrector. NNSplitter obfuscates 0.002% of weights and fixes their contribution inside the enclave. TEE-X compresses a whole vision transformer to fit inside ARM's TrustZone enclave. These designs constrain ours more than they supply it. They work because the enclave can repair an intermediate computation. Rasterizing Gaussians instead needs every primitive's true position, color and opacity on the GPU, so an enclave cannot "correct" a splat after the fact. The only lever left is what gets released, and when. That is why the mechanism here is release gating rather than weight obfuscation. It is also why we target metering of bulk theft rather than the functional-locking guarantees those papers report.

Threat Model and Mechanism

The attacker controls the operating system and can read all normal-world and GPU memory. The attacker can also feed arbitrary camera poses to the app. The enclave, an ARM TrustZone trusted application under OP-TEE, holds four things: the per-chunk keys, a compact index of chunks and their importance-ordered blob ranges, a ledger of everything released so far, and the release policy. The full scene stays encrypted on flash storage. Enclave memory of under 16 MB, as in DarkneTZ and MirrorNet, cannot hold the scene, which CLoD-GS reports as 445 MB even after compression on its Amsterdam scene. So the enclave stores only metadata and streams decryption through a shared buffer. The cost of crossing the boundary is a first-order concern: AegisGuard found that host-to-enclave transfer exceeds 60% of inference latency.

Write $w \in [0,1]$ for the opacity ramp LODGE applies to a fine chunk at the current camera distance. Write $N$ for the number of fine blobs in that chunk, and $g(w)$ for the fraction of the chunk's rendered contribution captured by its top-ranked blobs. The enclave releases the smallest prefix $k$ of the importance-ordered chunk such that

$$\frac{\sum_{i \le k} c_i}{\sum_{i \le N} c_i} \ge \min\!\left(1, \frac{w}{\tau}\right),$$

where $c_i$ is blob $i$'s average rendered contribution on training views, and $\tau$ is a tunable fraction of the fade at which the full chunk must be present. Releases are monotone, and the ledger records them, so pose oscillation around a boundary releases nothing new. Hysteresis in the style of Karner et al. is therefore free from a leakage standpoint. Against pose spoofing, the enclave enforces a cap on newly released primitives per second and a plausibility bound on camera speed. Neither stops a patient attacker. Both turn "copy the file" into "walk the city", and we measure how long that walk takes. Side channels of the kind shown by SgxPectre could expose keys. We leave them out of scope and state that limitation explicitly.

Research Program

We first train LODGE models on the target scenes and compute per-blob contribution scores. We then reorder each chunk so that a prefix gives the best partial render, and we check that partial prefixes composite cleanly under LODGE's opacity ramp. The open technical question at this step is whether a sparse prefix of fine blobs, drawn at low opacity, actually looks like a faded full chunk. Or does it look like noise, in the way that structurally mismatched LOD layers produce the ghosting BungeeNeRF describes? Next we implement the enclave policy and a decrypt-to-shared-buffer path on an NVIDIA Jetson AGX Xavier with OP-TEE, the platform TEE-X used. We profile decryption and copy cost against LODGE's existing storage bottleneck.

Finally we trace out frontiers between leakage and popping by sweeping $\tau$ and the fade-band width. We run three attacks against each operating point. The first dumps GPU memory along legitimate trajectories. The second spoofs poses under the rate cap. The third is recapture: train a fresh Gaussian scene from rendered frames alone. The third sets the floor below which no release policy can help.

Baselines

The naive reference is LODGE itself running on the same device, with the scene decrypted wholesale into normal-world memory, in the manner of conventional file encryption. It shows the image quality and frame rate we must stay close to. Its leakage is total. On Hierarchical 3DGS SmallCity, LODGE reports a PSNR of 26.57, against 26.42 for hierarchical 3DGS, and 41 FPS on an iPhone 13 mini. Our gated renderer should stay within a few tenths of a dB of the LODGE model we retrain, measured on static views. We found no reported result on Lacuna for any temporal popping metric on these benchmarks, so we will establish all popping numbers ourselves.

The strongest existing competitor for this question is minimal-leakage chunk gating. The enclave releases a whole chunk only when LODGE's ramp begins, and it uses the same ledger and rate cap. This is what one would build by bolting enclave keys onto LODGE without our weight-proportional ordering. It isolates our key ingredient, and the comparison runs on the same model, trajectories, device and leakage accounting. A second variant of this baseline widens the fade band until popping matches ours, which lets us compare leakage at equal visual quality.

The third baseline is server-gated streaming. Following LapisGS-style layered progressive delivery, the server applies the identical policy based on poses the client reports. We emulate round-trip times representative of mobile networks, and the server's prefetch margin is tuned to its best popping for each leakage budget.

An ablation keeps proportional release but uses random rather than importance ordering. A second ablation removes the ledger, which shows how much oscillation and spoofing gain without it. We count our method as beating a baseline if its frontier dominates on held-out trajectories. That means less popping at every matched leakage level, or lower attacker reconstruction PSNR at matched popping, with frame rate within 10% of plain LODGE.

Why not just…?

Why not just encrypt the scene file and decrypt it for rendering? That stops casual copying from storage and nothing else. The decrypted file sits in normal-world and GPU memory, where an operating-system-level attacker reads it in one step. The naive baseline measures exactly this: leakage equals 100% of the scene after a single launch.

Why not just gate the stream from a server and skip the enclave? This is the real threat to the proposal. Server gating enforces the same release logic, and its leakage after delivery is identical, because the client keeps what it receives either way. What the enclave adds is on-device decisions without a network round-trip, plus offline use. Our prediction is that delay forces the server to prefetch more, or to deliver late and pop, at any given leakage level. The server-gated baseline tests this directly. If its frontier matches ours at realistic latencies, the scientific contribution narrows to the weight-proportional release policy, which applies equally to both deployments. We would report that outcome honestly.

Why not just watermark the Gaussians? Watermarks identify a thief after the fact but do not limit what can be taken. NNSplitter makes this argument for passive protection of neural networks. Watermarking is complementary to gating, and can be layered on the released subset.

Why not just split the model the way neural-network enclave work does? Hiding a final layer, as DarkneTZ does, works for a classifier. MirrorNet already shows such a hidden layer can be retrained from about 1% of the training data. For splats there is no hidden computation to keep secret, because the GPU needs plain parameters to draw anything. An enclave-side corrector in the style of MirrorNet would have to rasterize inside the enclave. TEE-X needed aggressive compression just to run one vision transformer at about one second per image there, far from real-time rendering.

Proposed Experiments

We will evaluate on the Hierarchical 3DGS SmallCity and Campus scenes used by LODGE, on BungeeNeRF's satellite-to-street scenes, and on MatrixCity. Each scene gets scripted fly-through and walk-through trajectories, plus adversarial trajectories that oscillate around switching boundaries. Popping is measured against a full-detail reference render along each trajectory. The metrics are the peak and 99th-percentile frame-to-frame increase in error relative to that reference, together with LPIPS. Static-view quality is measured with PSNR, SSIM and LPIPS. Leakage is measured three ways: the fraction of unique fine primitives released; the PSNR of renders made solely from released primitives, on views held out from the trajectory; and, under spoofing within the rate cap, the wall-clock time to collect 50% and 90% of the fine content.

We also report enclave memory use, decrypt-and-copy latency per frame, and end-to-end FPS on the Jetson. Two checks are decisive. The first is whether weight-proportional release beats whole-chunk gating by a clear margin in leakage at equal popping on held-out trajectories. If it does not, the proposal's central mechanism fails. The second is whether the enclave version beats server gating at realistic latencies, which decides whether the TEE is necessary or merely convenient. A third, sobering check compares recapture attack quality against the gated leakage. If a few minutes of screen recording already yields a reconstruction as good as our leaked set allows, the protection buys time but not fidelity, and the note will say so.