It's Easier to Pirate with an Atlas…sian
Giuliana (Security Testing Engineer · Atlassian)
purplecon 2024 · Day 1 · Main Room
Overview
In this highly practical and engaging talk titled "It's Easier to Pirate with an Atlas…sian," Giuliana, a Security Testing Engineer at Atlassian, takes the audience on a journey through the process of reverse-engineering and bypassing the license verification mechanism of Jira Server. While humorously presented with the disclaimer "please do not actually do what I'm going to teach you," the core purpose of the talk is to illustrate advanced white-box penetration testing techniques. Giuliana demonstrates how internal security teams leverage deep access to code and debugging tools to understand application logic, identify vulnerabilities, and ultimately strengthen their products.

Key moments
- 0:00 Introduction and talk disclaimer
- 2:00 Why Atlassian pentesters learn to crack Jira
- 5:40 Invalid license input exposes stack trace
- 7:40 Decompiling Java .class files
- 9:40 Using debugger to find verification logic
- 11:50 Live demo: Finding signature verification
- 16:00 Conclusion: Hack like an engineer
It's Easier to Pirate with an Atlas…sian
Speakers: Giuliana, Security Testing Engineer, Atlassian
Conference: purplecon
YouTube: https://www.youtube.com/watch?v=SqZBIn0LoCk
Overview
In this highly practical and engaging talk titled "It's Easier to Pirate with an Atlas…sian," Giuliana, a Security Testing Engineer at Atlassian, takes the audience on a journey through the process of reverse-engineering and bypassing the license verification mechanism of Jira Server. While humorously presented with the disclaimer "please do not actually do what I'm going to teach you," the core purpose of the talk is to illustrate advanced white-box penetration testing techniques. Giuliana demonstrates how internal security teams leverage deep access to code and debugging tools to understand application logic, identify vulnerabilities, and ultimately strengthen their products.
The presentation focuses specifically on Jira Server, the self-hosted version of Atlassian's popular project management software, rather than its modern cloud counterpart. Giuliana explains that learning to "crack Jira" is a foundational exercise for new pentesters joining her team, designed to familiarize them with the product's massive codebase and the power of engineering-grade tools for security analysis. This talk is not about exposing a zero-day vulnerability in Jira but rather a masterclass in applying systematic reverse engineering and debugging methodologies to uncover critical application logic, which can then be leveraged for both offensive and defensive security purposes.
The talk matters significantly because it demystifies the process of analyzing complex enterprise applications. It highlights that even multi-million dollar software can have discoverable internal workings that, if not robustly secured, could be exploited. More importantly, it advocates for a "hack like an engineer" mindset, encouraging security professionals to adopt developers' tools and deep code understanding to conduct more effective and thorough security assessments, moving beyond superficial black-box testing.
Background
▶ Watch: Introduction and talk disclaimer (0:00)
The context of this talk is rooted in the distinction between Jira Server and Jira Cloud. While Atlassian has largely shifted its focus to cloud-based offerings, Jira Server remains widely deployed in corporate environments, often preferred for its on-premise control and customization capabilities. This older, self-hosted version is the target of Giuliana's demonstration, specifically its license validation mechanism. Unlike cloud services where licensing is managed remotely, Jira Server relies on a local license key provided by Atlassian, which needs to be verified by the running application.
Giuliana introduces the concept of white-box penetration testing, which is the primary mode of security assessment performed by her internal team at Atlassian. Unlike black-box testing, where testers have no prior knowledge of the system's internals, white-box testers have full access to source code, documentation, and collaborate directly with engineers. This privileged access allows for highly focused and efficient testing, enabling security professionals to delve deep into the application's logic and uncover subtle vulnerabilities that might be missed in a black-box scenario. The speaker emphasizes the benefits of this approach, highlighting how it enables a more precise and impactful security analysis.
The problem that this talk implicitly addresses is the inherent trust placed in self-hosted software and the mechanisms designed to enforce its licensing. When a user "gives Jira their money," they receive an opaque license string. The underlying challenge is to understand how Jira transforms this "gibberish" into meaningful license data (e.g., user count, edition type) and, critically, how it verifies the legitimacy of that license. For an internal security team, understanding and attempting to bypass this mechanism is a crucial exercise to ensure the integrity of their product and to train new team members in the art of deep code analysis.
Key Findings
▶ Watch: Invalid license input exposes stack trace (5:40)
The central "finding" of this talk is less about a novel vulnerability and more about the discoverability of critical application logic within a complex enterprise system like Jira Server, using standard engineering tools. Giuliana's methodology reveals how to pinpoint the exact code responsible for license validation and, by extension, how it could be bypassed.
The initial key observation arose from experimenting with an invalid license key. When a single character in a legitimate trial license was altered, Jira Server did not display a user-friendly error message. Instead, the application would simply hang indefinitely. A quick inspection using the browser's developer tools revealed a critical information leak: the entire stack trace of the server-side error was printed to the console. This stack trace served as a crucial breadcrumb, pointing directly to the method responsible for processing the license: checkAndGetLicenseText. This immediate exposure of internal server logic upon an invalid input is a significant security flaw in itself, as it provides attackers with invaluable insights into the application's structure.
Further investigation, guided by the stack trace, led to the identification of the atlassian-extras.jar file as the repository for the relevant license management code. After decompiling the necessary .class files, Giuliana was able to locate the checkAndGetLicenseText method in the source code. The most critical discovery within this method was the specific line signature.verify, which was identified through debugger-assisted tracing. This line was found to be the precise point where the cryptographic signature of the license was checked, and where an exception was thrown if the signature was invalid. The realization was that if this single verification step could be bypassed, a custom-generated license (with desired parameters like 10,000 users, Enterprise Edition) could potentially be accepted by Jira, even without a valid Atlassian signature.
In essence, the key findings are:
- Information Leakage: Invalid license input leads to a full stack trace exposure, revealing internal method calls.
- Target Identification: The stack trace directly points to
checkAndGetLicenseTextwithinatlassian-extras.jar. - Vulnerability Pinpointing: A debugger can precisely identify the
signature.verifymethod as the gatekeeper for license legitimacy. - Bypass Potential: By targeting and neutralizing this specific
signature.verifycall, the entire license validation process could theoretically be subverted.
Technical Deep Dive
▶ Watch: Decompiling Java .class files (7:40)
The technical deep dive presented by Giuliana meticulously outlines the steps required to reverse-engineer and understand Jira Server's license validation. This process is a testament to the power of combining publicly available information, standard development tools, and a methodical approach.
The first step involves obtaining the Jira Server application. Giuliana instructs attendees to download the Jira source from the official Jira Data Center download archives. While the talk focuses on Jira Server, the download link provided is for Data Center, implying that the underlying license mechanism is similar. Once downloaded, the application can be run locally. A crucial part of this setup is enabling XDebug, a remote debugging protocol for Java Virtual Machine (JVM) applications. This is achieved by adding a specific flag (e.g., -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005) to the JVM startup command. Running Jira with XDebug enabled opens a debugging port, allowing an Integrated Development Environment (IDE) like IntelliJ IDEA to attach and step through the executing code.
Upon running Jira locally (typically on localhost) and logging in with default admin/admin credentials, the next step is to navigate to the license page. Here, a free trial license is usually pre-filled. The initial investigative technique is experimentation with input. By simply altering a single character in the license key and attempting to update it, Giuliana demonstrates that Jira hangs. Crucially, inspecting the browser's developer console reveals the full Java stack trace, providing a treasure trove of information. The first line of interest in the stack trace is often a method like checkAndGetLicenseText, which immediately suggests its relevance to license validation.
With a target method identified, the next phase involves decompilation. The downloaded Jira application consists of numerous JAR files, which are essentially ZIP archives containing compiled Java .class files. The stack trace indicates that the relevant code resides within atlassian-extras.jar. Since .class files are bytecode and not human-readable, they need to be decompiled back into Java source code. While various decompilers exist, IntelliJ IDEA, Giuliana notes, has a decompiler built-in. By loading atlassian-extras.jar (or all JARs for broader searching) into IntelliJ as a library, the IDE can automatically decompile the bytecode, allowing developers and pentesters to search for the target method (checkAndGetLicenseText) using standard text search (Ctrl+F or Cmd+F).
Once the method is located in the decompiled source, the debugger becomes indispensable. A breakpoint is set within the checkAndGetLicenseText method, specifically at a line suspected of performing the critical validation. Giuliana highlights keyManager.getInstance().verify as a strong candidate. With the breakpoint active, submitting the invalid license again will cause the debugger to pause execution at that point. The debugger provides real-time insights into the application's state, including variable values and the execution flow. By stepping through the code line by line, particularly "stepping into" suspicious methods, Giuliana demonstrates how to trace the exact path of execution until the exception is thrown. This process precisely identifies signature.verify as the function responsible for throwing the exception when an invalid license signature is encountered.
The ultimate goal, as explained, is to bypass this signature.verify check. While the talk doesn't detail the recompilation and re-signing of the JAR file (referring to them as "sparkle bits"), the implication is that modifying one or two lines of decompiled code (e.g., making signature.verify always return true, or catching the exception and returning true) and then recompiling and replacing the modified JAR file would effectively neutralize the license validation. Giuliana also mentions the existence of public GitHub repositories (e.g., "crack jira") that contain Python scripts capable of generating a valid-looking license payload without the cryptographic signature, which would then be accepted by the modified Jira instance.
This technical deep dive demonstrates a complete methodology: from observing external behavior (hang, stack trace) to internal code analysis (decompilation), and finally to precise vulnerability identification (debugger-assisted tracing) leading to a theoretical bypass.
Demo / Proof of Concept
▶ Watch: Live demo: Finding signature verification (11:50)
Giuliana provided a concise and effective live demonstration of the technical steps involved in identifying the license verification logic using a debugger. The demo served as a crucial proof of concept, illustrating the theoretical steps outlined in the technical deep dive in a real-world scenario.
The demonstration began with a Jira Server instance running locally on localhost, accessible through a web browser. The speaker navigated to the license configuration page, where a default trial license key was displayed. To initiate the debugging process, Giuliana first showed how to modify the existing license key by simply changing a single character. This action was followed by clicking the "Update License" button. As described in the talk, this immediately caused the Jira application to hang and become unresponsive from the user's perspective.
Crucially, Giuliana then switched to her IntelliJ IDEA environment, which was already attached to the running Jira instance via the XDebug port. With the application hung, the debugger had already paused execution at a previously set breakpoint within the checkAndGetLicenseText method. The IDE's debugger interface displayed the current state of the application, including the values of various variables and the full call stack.
The core of the demo involved stepping through the code using the debugger's controls. Giuliana specifically used the "step into" functionality to delve deeper into the keyManager.getInstance().verify method. This allowed the audience to visually follow the execution path into the cryptographic verification logic. As the debugger progressed, it eventually reached the precise line of code: signature.verify. At this point, the debugger highlighted that this was where the exception was being thrown, preventing the invalid license from being processed and causing the application to hang.
This live demonstration vividly illustrated:
- How an invalid input can trigger a critical internal error.
- The utility of a debugger in understanding complex application flow.
- The ability to pinpoint the exact line of code responsible for a specific security control (license verification).
The demo effectively validated the theoretical premise that the signature.verify call is the critical gatekeeper, and by observing its behavior in real-time, one could identify it as the primary target for a license bypass.
Defensive Implications
▶ Watch: Conclusion: Hack like an engineer (16:00)
While Giuliana's talk is presented as an offensive exercise in "pirating" Jira, its underlying message carries significant defensive implications for both software vendors and organizations using self-hosted enterprise applications.
For software vendors like Atlassian, the talk underscores the immense value of white-box penetration testing and internal security research. By actively seeking to understand and bypass their own product's security mechanisms, Atlassian's security team gains invaluable insights into potential weaknesses before external attackers can exploit them. This proactive approach allows them to strengthen their code, improve error handling, and ensure the robustness of critical features like license validation. The methodology taught to new pentesters, though seemingly offensive, is a powerful defensive training tool.
One critical defensive implication highlighted by the talk is secure error handling. The fact that an invalid license input caused Jira to hang and, more importantly, to print a full Java stack trace to the browser's developer console is a significant security flaw. Stack traces contain sensitive internal information about the application's structure, method calls, and even file paths, which can provide attackers with a roadmap to understand the codebase and identify further vulnerabilities. Defenders must ensure that applications gracefully handle errors, providing only generic, non-informative messages to users and logging detailed errors internally for debugging purposes, never exposing them directly to the client.
Furthermore, the talk emphasizes the need for robust license validation mechanisms in self-hosted software. While the core vulnerability isn't a cryptographic flaw in the signature algorithm itself, the ease with which the validation logic can be identified and targeted highlights that such checks must be implemented with defense-in-depth principles. This includes:
- Obfuscation or Anti-Tampering: While not foolproof, making it harder for attackers to easily decompile, understand, and modify critical code can raise the bar.
- Runtime Integrity Checks: Implementing checks at various points in the application lifecycle to detect if core components have been tampered with.
- Server-Side Verification: For applications that can communicate with a vendor's servers, periodic online verification of licenses can add an extra layer of defense against offline bypasses.
For organizations deploying self-hosted enterprise software, the talk serves as a cautionary tale. It demonstrates that even widely used and trusted applications can have internal workings that, if not properly secured or configured, could be manipulated. Defenders in these organizations should:
- Prioritize Updates and Patches: Vendors frequently release security updates to address such issues, and applying them promptly is crucial.
- Monitor for Tampering: Implement integrity monitoring for critical application files and directories to detect unauthorized modifications.
- Implement Network Segmentation: Limit network access to self-hosted applications to prevent unauthorized users from even attempting such bypasses.
- Adopt a "Hack Like an Engineer" Mindset: Security teams within these organizations can benefit from understanding the techniques demonstrated. By knowing how an attacker might approach reverse-engineering a license, they can better anticipate and defend against such attacks, or even use similar methods to audit their own custom applications.
Ultimately, the talk is a powerful reminder that security is not just about perimeter defenses or known exploits, but about deeply understanding the internal mechanics of software. By adopting the tools and mindset of engineers, security professionals can move from reactive patching to proactive hardening, building more resilient applications from the inside out.
Key Takeaways
- Embrace White-Box Pentesting: Deep access to source code and internal documentation, combined with collaborative relationships with engineers, enables highly effective and focused security assessments.
- Utilize Engineering Tools for Security: Debuggers (like XDebug with IntelliJ IDEA) are invaluable for understanding application logic, tracing execution flow, and pinpointing critical security controls or vulnerabilities in complex software.
- Beware of Information Leakage: Exposing full stack traces or verbose error messages to users or client-side consoles provides attackers with a roadmap to internal application structure and potential attack vectors.
- Robust License Validation is Crucial for Self-Hosted Software: Mechanisms like cryptographic signature verification are essential, but their implementation must consider the potential for reverse engineering and direct code manipulation.
- "Hack Like an Engineer": Security professionals should adopt the mindset and tools of software engineers to gain a deeper understanding of how applications truly work, allowing for more comprehensive security analysis and effective defensive strategies.
- Proactive Internal Security Research: Vendors benefit significantly from internal teams actively attempting to bypass their own product's security features, leading to stronger, more resilient software.
About the Speaker(s)
Giuliana is a Security Testing Engineer at Atlassian, where she is part of a relatively small but impactful pentesting team. Her journey into security began with a love for mathematics, which led her to explore coding through programs like the Girls Programming Network (GPN). She pursued computer science at the University of New South Wales (UNSW) before gaining corporate experience at IIG. Ultimately, she found her passion in security at Atlassian, specializing in white-box penetration testing. Giuliana's role involves meticulously examining Atlassian's products with full access to their codebase, collaborating closely with engineers to identify and mitigate security risks. This talk marks her very first conference presentation.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
A competent walkthrough of basic reverse engineering methodology using Jira Server license validation as a teaching example. It's a perfectly fine intern onboarding exercise presented publicly, but there's nothing here that anyone who's touched a Java debugger hasn't done a hundred times. The 'cracking' angle is marketing—this is 'how to use IntelliJ and a stack trace.'
Heather Calloway (CISO) — SOLID
Solid internal training exercise packaged as a conference talk. Demonstrates white-box pentesting methodology clearly, but the strategic value for most CISOs is limited — this is junior analyst onboarding material, not a threat briefing.