Code Protection Techniques when Distributed in Source Format: an Adobe Connect Pod Written in Javascript

Alessandro Simonetta, Francesco RinaldiSYSTEM 2021

Abstract

This paper presents a multi-layered security framework designed to protect JavaScript-based applications, specifically "Pods" for the Adobe Connect platform, from unauthorized redistribution and intellectual property theft. By integrating visual watermarking, robust code obfuscation, and a server-side license manager that dynamically injects critical logic at runtime, the authors create a "hollow client" architecture. This approach ensures that the distributed source code remains non-functional without authorized server interaction, significantly increasing the effort required for reverse engineering and unauthorized use.

Introduction

In traditional software development using compiled languages like C++, source code is transformed into binary machine code, creating a natural barrier against human inspection and modification. However, the modern web ecosystem relies heavily on JavaScript, which is distributed in its raw source format. When a developer creates a web-based tool—such as a "Pod" plugin for the Adobe Connect e-learning platform—the entire logic of that tool is delivered directly to the user's browser.

This transparency creates a significant intellectual property (IP) risk: any user can "view source," copy the logic, and redistribute the software without permission. As the industry shifts toward microservices and decoupled front-ends, protecting client-side code has become a critical challenge for developers seeking to monetize proprietary logic.

The Concentric Protection Model

To address these vulnerabilities, the authors propose a "concentric" protection model. This strategy does not rely on a single defense but rather layers three distinct levels of security to create a cumulative deterrent.

The concentric protection model illustrating the three layers of defense: watermark, obfuscation, and license manager.
  1. Basic Level (Watermarking): This layer involves indelibly marking the Graphical User Interface (GUI) with the licensee’s logo and name. To prevent simple removal via HTML/CSS editing, the authors suggest using complex calculations to render these marks at runtime.
  2. Intermediate Level (Code Obfuscation): The source code is transformed into a functionally equivalent but human-unreadable version. This process includes renaming variables to nonsensical strings (e.g., _0x3f436f), stripping formatting, and inserting "junk code" to confuse manual analysis.
  3. Server Level (License Manager): This is the most robust layer, moving the application toward a "hollow client" state where the software is distributed incomplete.

System Architecture and Interactions

The core of the proposed system is the interaction between the client-side Pod and a remote License Manager. The application is designed to be non-functional in its offline state. Upon initialization, the client must authenticate with the server to retrieve the "missing" pieces of logic.

The context-scheme diagram illustrating the interactions between the teacher, student, system, and license manager within the Adobe Connect environment.

As shown in the context-scheme, the License Manager acts as a central authority. When a session begins, the server performs several critical tasks:

  • Usage Monitoring: It verifies the client's license status in real-time.
  • Dynamic Code Injection: The server sends the final, essential pieces of JavaScript required for the application to function via AJAX calls.
  • Integrity Verification: Using hashing functions, the server verifies that the client-side code—including the watermarks—has not been tampered with. If a mismatch is detected (e.g., if a user tried to remove a logo), the server can terminate the session.

Implementation and Key Insights

The authors demonstrated this framework by building a functional Pod using the Adobe Connect JavaScript SDK. A key insight from this case study is that security is relative. No client-side protection is absolute; the objective is to make the "cost" of cracking the software—in terms of time, expertise, and effort—prohibitively higher than the cost of purchasing a legitimate license.

The "hollow client" concept proved particularly effective. By keeping critical logic on the server and only delivering it to authenticated sessions, a stolen source file becomes an incomplete shell. Furthermore, the use of hashing as a branding guard ensures that even if a user manages to run the code, they cannot easily rebrand it as their own without breaking the server-side integrity checks.

Results and Limitations

The proof-of-concept successfully integrated these layers, showing that a Pod could request and execute code snippets from a remote server via $.ajax calls without significant functional degradation. However, several limitations remain:

  • Connectivity Dependency: The most effective layer (the License Manager) requires a constant internet connection. Loss of connectivity renders the application unusable.
  • Evolution of De-obfuscation: While obfuscation deters humans, automated "beautifiers" and de-obfuscation tools are becoming more sophisticated, potentially lowering the barrier for attackers over time.
  • Performance Overhead: Fetching code chunks at runtime introduces latency, which may impact user experience in high-performance or complex applications.

Conclusion

While originally tailored for the Adobe Connect ecosystem, this three-tier methodology is generalizable to any JavaScript-based distribution format, including browser extensions and other plugin architectures. By combining visual, structural, and server-side defenses, developers can significantly mitigate the risks associated with distributing source-format software.

Summary updated

BibTeX
@inproceedings{simonetta2021code,
  author = {Alessandro Simonetta and Francesco Rinaldi},
  title = {{Code Protection Techniques when Distributed in Source Format: an Adobe Connect Pod Written in Javascript}},
  booktitle = {SYSTEM},
  year = {2021},
}
Figure