UV Islands as Split States: Non-Malleable Provenance Tags for Textured 3D Assets

When a 3D object is textured, its surface is cut into pieces ("UV islands") and flattened onto a 2D image called a texture atlas. Image-based neural editors process that atlas as if neighboring pixels were neighboring surface points. This is false at the cuts, and it is why AI-generated textures show visible seams. We propose to treat this flaw as useful. If an editor cannot pass information between distant islands, then its effect on data hidden in one island is independent of its effect on data hidden in another. That is exactly the "split-state" condition under which cryptographers know how to build non-malleable codes. A non-malleable code is an encoding where any allowed tampering either leaves the message intact or turns it into something unrelated, such as an error flag, and never into a predictably altered version of the original.

The practical goal is provenance and licensing tags embedded in textured assets that cannot be silently falsified by AI re-texturing or editing. The concrete failure we target is a tag that comes back from an edit as a valid but wrong message, such as a different owner ID or a flipped license field. Classical error-correcting codes allow this failure, and current 3D watermarking does nothing to prevent it. The proposal has two parts. The first is a measurable condition, low cross-island influence of a given editor, under which a split-state non-malleable code embedded across distant surface regions provably prevents related-message mauling. The second is a placement rule, derived from what is known about seam artifacts, that predicts which editors satisfy the condition and which break it.

Core Claim

Suppose a message is encoded into shares, and each share is embedded by a robust per-region watermark into a separate surface region. An image or texture editor $E$ applied to the asset then induces a tampering function on the extracted shares. This function is the composition of embedding, editing, and extraction. Let $I_E(A \to B)$ be the probability that bits extracted from region $B$ change when only the content of region $A$ is perturbed before editing. When $I_E(A \to B)$ and $I_E(B \to A)$ are near zero, the induced tampering approximately factorizes into independent functions on each share. A split-state non-malleable code then applies directly, and it needs no trusted setup. This is the plain model, where no common reference string or shared key exists, as emphasized in Continuously Non-Malleable Codes in the Split-State Model from Minimal Assumptions.

The seam literature tells us in advance which editors violate the condition. Seam-fixing machinery exists precisely to move information across cuts. Paint3D's position map, which writes 3D coordinates into texels (Paint3D), does this. So does TEXGen's interleaving of 2D convolutions with 3D point attention (TEXGen), and so does geometry-aware cross-seam blending (Cheng and Mu). These are cross-state channels. The placement rule follows: shares must sit in regions that are far apart both in the 2D atlas and in 3D geodesic distance. The 3D separation should exceed the effective range of the editor's 3D mixing. The deliberate tension is that the better an editor is at removing seams, the weaker the split-state guarantee becomes. We intend to quantify that trade-off rather than hide it.

Relation to Prior Work

The cryptographic side supplies the method and also limits our ambitions. The split-state model, in which tampering acts independently on two or more parts, has plain-model constructions. Non-Malleable Codes for Small-Depth Circuits shows that global shallow-circuit tampering can be reduced to split-state tampering via pseudorandom switching lemmas. We take the converse route: geometry provides the split, and no reduction is needed. For more than two regions and for color-like edits, Non-Malleable Secret Sharing against Affine Tampering is the natural template, since per-island brightness and contrast shifts are affine.

General plain-model codes against bounded-polynomial-time tampering (Non-Malleable Codes Against Bounded Polynomial Time Tampering, (Nondeterministic) Hardness vs. Non-malleability) would cover cross-island editors. However, they rest on derandomization assumptions and achieve only inverse-polynomial security, which rules them out as a practical default here. We treat them as the theoretical fallback for editors that fail our influence test.

On the graphics side, the seam papers motivate the proposal. UV-free Texture Generation with Denoising and Geodesic Heat Diffusion and TexGarment document that 2D receptive fields ignore 3D adjacency across cuts. We reuse that diagnosis as a security property. 3D watermarking work supplies the embedding technique but not the guarantee. Deep3DMark trains through a simulated attack layer, reports over 96% bit accuracy under rotation and scaling, and works only on untextured geometry. Deep 3D-to-2D Watermarking extracts from renderings but ignores seams. Blind invisible watermarking for 3D meshes with textures predates neural editors. None of these says what a damaged tag decodes to. Our contribution is the layer above them, together with the influence analysis that justifies it. The research file found no prior work combining non-malleable codes with UV texture structure.

Research Program

The system has three parts. The first is a region selector. Given a mesh and its atlas, it chooses $k$ surface regions, defined on the 3D surface rather than by atlas pixels, that maximize the minimum pairwise separation. Separation is measured jointly as 2D atlas distance and geodesic distance computed with the heat method. Defining regions on the surface means that re-unwrapping with xatlas or repacking islands changes where each region lands in the atlas but not which texels belong to it. The extractor reads each region by sampling the surface, so repacking becomes close to an identity operation on the shares.

The second part is a per-region embedder and extractor. This is a small learned texture watermark trained in the style of Deep3DMark's attack layer. It is trained against benign pipeline operations: compression, mipmapping, re-baking after re-unwrapping, and mild seam blending. The goal is that the extracted share bits survive these operations exactly, with an inner error-correcting code absorbing residual bit noise.

The third part is the outer code. We use a plain-model split-state non-malleable code for two regions, or affine-resilient non-malleable secret sharing for $k > 2$ regions, wrapped around the payload.

The analysis centers on estimating $I_E(A \to B)$ for each editor. We perturb region $A$ with random and adversarially optimized changes, run the editor, and measure bit changes in region $B$ as a function of 2D and geodesic separation. This yields an influence-versus-distance curve per editor. The curve gives the minimum separation the placement rule must enforce. A simple union-bound argument converts measured influence into a bound on the residual non-split component of the tampering: the deviation from split-state behavior is at most the sum of pairwise influences. This bound, added to the code's own split-state error, is the claimed end-to-end mauling probability.

Baselines

The naive reference point is an unprotected tag: the payload with only the inner error-correcting code, embedded in a single region. It shows how often realistic edits produce valid-but-wrong decodes when nothing prevents it.

The strongest practical competitor is an error-correcting code plus a keyless checksum, such as Reed–Solomon followed by a CRC or hash, replicated across the same $k$ regions. Against random corruption it is hard to beat, and it is what an engineer would ship. It uses the identical embedder, regions, payload length, and benign-transform training, so the only variable is the outer code. Beating it means two things. First, the rate of related-message decodes must stay statistically indistinguishable from zero under adaptive split-state attacks on which the checksum baseline is mauled at a high rate. Second, the outer code must cost no more than a few points of extra payload overhead and must not degrade texture quality.

The second strongest competitor is a public-key signature over the payload, embedded alongside it. It is run with the same embedder and capacity budget.

The key ablation removes the placement rule. It places the non-malleable shares randomly, or in regions that are adjacent across a seam, keeping everything else fixed. This isolates whether geometric separation, rather than the code alone, carries the guarantee.

For texture fidelity, the reference points are the generators' own published quality. Paint3D reports a text-to-texture FID of 27.28 against 38.93 for the previous best (Paint3D). UV3-TeD reports an FID of 54.20 on ShapeNet chairs against 63.35 for PointUVDiff (UV-free Texture Generation). Our target is that embedding moves render FID on these generators' outputs by much less than the gaps between those methods. For mauling rate on textured assets, no reported result was found on Lacuna, so the checksum baseline is measured here.

Why not just…?

Why not just use an error-correcting code with a checksum? Against accidental damage this would largely work. We expect it to match our method on non-adaptive edits and will report that honestly. Its weakness appears against a knowledgeable attacker. Linear codes and linear checksums are malleable by additive offsets, and adding a fixed difference to each region's bits is a split-state operation. Such an attacker never needs to see the other region, so an island-local edit can flip a chosen license field while the checksum still verifies. This is the failure mode the non-malleability literature formalizes (Non-Malleable Codes for Small-Depth Circuits). The adaptive-attack experiment below settles the question directly.

Why not just sign the payload? A signature gives authenticity that a non-malleable code does not. This is a real threat to the proposal's relevance whenever a public-key infrastructure for asset creators exists. Our scope is the setting without one: anyone can decode the tag, nobody holds keys, and the claim is limited to "edits cannot produce a related false tag." We do not claim protection against an attacker who strips the tag and embeds a fresh one. We will also measure how often signature verification fails under benign re-baking compared with our scheme. A signature that breaks under routine pipeline steps yields only "invalid," which is safe but uninformative. That shared failure behavior is why the two approaches should be compared on false-rejection rate as well as forgery.

Why not just put a strong watermark in one island? Without separate states there is nothing for split-state security to work with. A single-region tag reduces to the error-correcting-code case. The placement ablation tests exactly this.

Why not use a general plain-model code against bounded-time tampering and forget geometry? Those constructions rely on derandomization assumptions and give only inverse-polynomial security (Non-Malleable Codes Against Bounded Polynomial Time Tampering). They are not built for kilobit payloads inside texture budgets. Geometry gives us the split cheaply, and where it fails, our influence curves show which editors would require the heavier machinery.

Proposed Experiments

The assets are textured meshes from Objaverse (Objaverse) and the high-resolution subset in TexVerse, plus ShapeNet chairs (ShapeNet) for comparison with UV3-TeD.

The editors span the seam spectrum. They include plain 2D diffusion image-to-image editing on the atlas, which should be local; seam blending in the style of Cheng and Mu; Paint3D's UV refinement stage with position maps; and TEXGen re-texturing, which mixes information globally in 3D. UV3-TeD regeneration serves as a full overwrite, and its decodes should be "error" rather than mauled.

The first decisive check is the influence curve itself. We predict that $I_E(A \to B)$ for local 2D editors falls to near zero beyond a small atlas and geodesic distance, while TEXGen's influence stays high at large geodesic distances. If local editors show substantial cross-region influence, the core claim fails.

The second check is adaptive mauling. We optimize an island-local attacker, constrained to edit each region independently, to change one payload field. We report the fraction of outcomes that decode to the original, to "error," or to a related message, for the checksum baseline, the signature, and our code, with and without the placement rule. Success means the related-message rate for our code is near zero while the checksum baseline is substantially mauled. For a seam-aware attacker built on TEXGen, we expect our guarantee to weaken in proportion to the measured influence. Confirming that prediction, rather than avoiding it, is part of the result.

The third check covers fidelity and robustness: render FID and user-visible artifacts for watermarked versus clean assets, and exact payload recovery after xatlas re-unwrapping and repacking, compression, and mipmapping.