JEP-200 is a Java platform change that restricts which classes can be deserialised by default. It applies to Java object deserialisation and uses allowlists and class filtering to block unexpected types, reducing gadget-based remote code execution and other abuse of unsafe object streams.
How JEP-200 changes Java deserialisation
JEP-200 matters because Java deserialisation is not just a parsing step, it is a trust decision. By restricting which classes can be deserialised by default, the platform reduces the chance that an application will instantiate unexpected types from untrusted or semi-trusted byte streams, which is a common prerequisite for gadget-chain abuse.
The key shift is from permissive object reconstruction to controlled object admission. In practical terms, that means the runtime no longer treats every serialized class as equally acceptable. Instead, it narrows the set of classes that can be materialised, which helps block object streams that were never intended to become executable application state.
Why allowlists and class filters matter
Allowlists and class filters are the core defensive idea behind JEP-200. They force deserialisation to succeed only when the receiving application has an explicit expectation for the type being revived, rather than trusting the stream to define its own object graph.
This is important because object deserialisation can have side effects far beyond data recovery. If a malicious or compromised stream can trigger the construction of a dangerous gadget chain, the application may execute attacker-influenced logic during read time, before any business validation occurs.
The control is especially relevant in older Java ecosystems where serialized objects travel across application boundaries, message queues, caches, or remote interfaces. A class filter does not make deserialisation inherently safe, but it does remove a large amount of accidental attack surface.
Where exposure usually comes from
Exposure is often a product of design choices rather than a single bug. Applications that accept serialized objects from remote clients, loosely trusted services, or legacy middleware inherit the risk that a crafted stream will reach a deserialisation sink without sufficient type constraints.
That risk becomes more serious when the receiving system contains libraries with gadget-prone classes, broad reflection use, or complex object lifecycles. In those environments, even a small relaxation in admission rules can be enough to turn a data-handling feature into an execution primitive.
Organisations should therefore understand where serialization is still used, whether those paths are externally reachable, and whether any component still relies on implicit trust in object types rather than explicit validation.
How to use JEP-200 safely in practice
JEP-200 should be treated as one layer in a larger deserialisation hardening strategy. The safest posture is to minimise use of native Java serialization where possible, constrain the types that are actually required, and keep trusted boundaries narrow and well documented.
Where deserialisation cannot be eliminated, maintain explicit allowlists, review library dependencies that may introduce gadget classes, and test real application flows after platform upgrades so that security controls do not break legitimate object handling. For adjacent platform hardening, see the broader control guidance in the NIST SP 800-53 Rev 5 Security and Privacy Controls, the NIST Cybersecurity Framework 2.0, and the CIS Benchmarks.
For teams that want a security engineering lens on the surrounding application and dependency risks, the OWASP API Security Top 10, OWASP SAMM, and SLSA are useful complements when deserialisation is part of a larger software delivery chain.
What defenders should verify after a patch or platform change
After adopting JEP-200, defenders should not assume the job is finished. A hardened default reduces exposure, but it does not prove that no dangerous deserialisation path remains, especially if an application has custom serialization logic, alternate class loading behaviour, or compatibility exceptions that reopen risk.
Post-change review should focus on whether application errors indicate blocked object types, whether any business workflow depends on unsafe legacy serialization, and whether the change has shifted risk into adjacent integration points. In mature environments, this review also checks whether logging and monitoring can distinguish normal blocked admissions from attempted abuse.
That follow-up is what turns JEP-200 from a platform feature into an effective control: it shrinks the attack surface, then gives defenders a reason to inventory, validate, and keep watching the paths that remain.
Risk and Threat Considerations
Java deserialisation is a classic abuse path because it can turn untrusted bytes into live objects with methods, state, and side effects. Without class filtering, attackers can use gadget chains to pivot from object reconstruction to remote code execution, often before the application has a chance to apply normal input validation.
Failure mechanism: A stream reaches a deserialisation sink, the runtime instantiates an unexpected class or gadget sequence, and attacker-controlled object behaviour executes during read-time processing.
Impact: Successful exploitation can lead to code execution, application compromise, data theft, service disruption, and, in some environments, reuse of the compromised process to reach downstream systems or credentials.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
MITRE ATT&CK addresses the attack and risk surface, while NIST SP 800-53 Rev 5, CIS Controls v8 and OWASP ASVS set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| NIST SP 800-53 Rev 5 | SI-10 — Information Input Validation | Deserialisation filtering is a form of trusted input restriction for unsafe object streams |
| SC-18 — Mobile Code | Serialized objects can deliver executable behavior-like payloads that require restrictive handling | |
| SA-11 — Developer Testing and Evaluation | Secure deserialisation needs testing to confirm blocked types and legacy compatibility | |
| Recommendation — Validate and constrain deserialised input so only expected object types can be accepted. Restrict execution of untrusted payloads and review deserialisation paths for code-like behavior. Test deserialisation controls and verify unsafe object types are rejected after platform changes. | ||
| CIS Controls v8 | CIS-16 — Application Software Security | Deserialisation hardening is an application security issue in legacy Java systems |
| Recommendation — Harden application data handling to prevent unsafe deserialisation and gadget abuse. | ||
| OWASP ASVS | V5 — File Handling | Serialized object processing is a file and data handling trust boundary that can execute unsafe content |
| Recommendation — Treat serialized object ingestion as untrusted input and reject unexpected object types. | ||
| MITRE ATT&CK | T1068 — Exploitation for Privilege Escalation | Gadget-chain deserialisation can be used to gain execution and escalate control |
| Recommendation — Map unsafe deserialisation to attacker execution paths and hunt for exploitation attempts. | ||
Practitioner Guidance
Why practitioners should care: Treat JEP-200 as a boundary control, not a full remediation. It is most effective when paired with an inventory of every place your Java estate still accepts serialized objects, because the remaining exposure usually sits in legacy integrations and compatibility exceptions.
What to watch for: Watch for applications that rely on permissive deserialisation for convenience, especially where object streams cross trust boundaries or where library upgrades change which classes are admitted. Those are the places where a security hardening change can silently become either a production issue or a missed hardening opportunity.
Practitioner takeaway: The safest long-term pattern is to reduce native serialization use, constrain what is allowed, and treat every deserialisation path as a potential security control point rather than a routine data-format conversion.
Related resources from NHI Mgmt Group
Deepen Your Knowledge
Free weekly newsletter
Subscribe to the NHI & AI Identity Journal
The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.
Bonus 33% off our NHI Course when you subscribe.
Reviewed and updated by the NHIMG editorial team on November 16, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org