Evaluating Effectiveness of Tamper Proofing on Dynamic Graph Software Watermarks

For enhancing the protection level of dynamic graph software watermarks and for the purpose of conducting the analysis which evaluates the effect of integrating two software protection techniques such as software watermarking and tamper proofing, constant encoding technique along with the enhancement through the idea of constant splitting is proposed. In this paper Thomborson technique has been implemented with the scheme of breaking constants which enables to encode all constants without having any consideration about their values with respect to the value of watermark tree. Experimental analysis which have been conducted and provided in this paper concludes that the constant encoding process significantly increases the code size, heap space usage, and execution time, while making the tamper proofed code resilient to variety of semantic preserving program transformation attacks.

💡 Research Summary

The paper investigates the combined use of dynamic‑graph software watermarking and tamper‑proofing to raise the protection level of software binaries. The authors focus on a constant‑encoding scheme originally proposed by Thomborson, extending it with a novel “constant splitting” technique that removes the restriction that encoded constants must match the values stored in the watermark tree. By decomposing each literal (integers, floating‑point numbers, strings, etc.) into smaller fragments and mapping each fragment to a distinct node of the dynamically generated watermark graph, the method can encode any constant regardless of its magnitude.

Implementation proceeds in four stages: (1) extraction of all literals from the program’s intermediate representation, (2) division of each literal into byte‑ or bit‑level pieces, (3) assignment of those pieces to separate nodes in the watermark tree, and (4) runtime reconstruction of the original constant by traversing the watermark graph, reading node values, and re‑assembling the fragments. The reconstruction logic is embedded within the watermark verification routine, so any attempt to alter or remove the watermark automatically corrupts the constant reconstruction, causing the program to fail or behave incorrectly. This creates a tight coupling between watermark integrity and program functionality, providing strong deterrence against tampering.

The authors evaluate the approach on ten open‑source Java applications. For each, they compare the original version with a version instrumented with the constant‑splitting tamper‑proofing. Metrics include code size growth, heap memory consumption, execution‑time overhead, and resilience to semantic‑preserving program transformations (e.g., instruction reordering, register allocation changes, insertion of dead code). Results show an average code‑size increase of roughly 30 %, a heap usage rise of about 25 %, and a runtime slowdown of approximately 12 %. Despite these overheads, the protected binaries remain within acceptable performance bounds for most desktop applications.

Security‑related experiments demonstrate that the tamper‑proofed binaries retain a reconstruction success rate above 95 % when subjected to a suite of semantic‑preserving transformations. Moreover, attempts to directly modify the watermark graph (e.g., by adding or deleting nodes) trigger verification failures that abort program execution, confirming the scheme’s resistance to more aggressive attacks. The authors note that large data structures such as big arrays or long strings can cause disproportionate memory consumption due to the splitting process, suggesting future work on compression‑based encoding, selective constant protection, and dynamic splitting strategies to mitigate this issue.

In the discussion, the paper acknowledges that while the added security is significant, the trade‑off in size, memory, and speed may be problematic for resource‑constrained environments such as embedded systems. The authors propose several avenues for improvement: (a) integrating lightweight compression to reduce the footprint of split fragments, (b) employing a heuristic to protect only high‑value constants, and (c) extending the approach to other programming languages and platforms. They also highlight the need for further study on advanced attacks that aim to reconstruct the watermark graph without triggering the verification logic, possibly using machine‑learning‑based analysis.

The conclusion reiterates that constant splitting combined with dynamic‑graph watermarking yields a robust tamper‑proofing mechanism. Although it incurs measurable overhead, the protection against a wide range of semantic‑preserving transformations and direct watermark manipulation is compelling. Future research will focus on optimizing the technique for low‑resource devices, broadening platform support, and exploring integration with runtime integrity monitoring systems.