FST Serialization is a fast object serialisation library for Java that converts objects to and from a compact binary form. It is used for caching, messaging and persistence, and like other Java deserialisation mechanisms it can expose applications to gadget-based attacks if it processes untrusted input.
What FST Serialization Does
FST Serialization is a Java object serialisation library that turns objects into a compact binary form for storage, caching and messaging. Its value is speed and payload efficiency, but its security posture is the same broad class of concern as other Java deserialisation mechanisms: if untrusted data reaches the deserialiser, the application may process attacker-controlled object graphs.
Why It Matters in Java Applications
Serialisation is not just a transport detail. It is a trust boundary, because the application is asked to rebuild in-memory objects from bytes that may have originated outside the process. That makes the library relevant anywhere an application accepts data from queues, caches, RPC handlers, files or persisted state that can be influenced by another system or actor.
In practice, the risk is not the compact format itself. The risk is the assumption that a binary payload is safe simply because it is not human-readable. A compact encoding can still carry dangerous type information, object references or gadget chains if the surrounding application treats the stream as trusted.
How Exposure Usually Arises
Exposure often appears when developers use a serialisation library for convenience and then reuse the same code path for internal and external input. A message broker, cache layer or persistence store may seem trusted at design time, but compromised upstream services, malicious tenants, deserialisation bugs or poisoned stored objects can break that assumption.
Java deserialisation issues are especially sensitive when libraries instantiate application classes during read operations. If those classes have side effects, validation gaps or unsafe method invocation paths, an attacker may be able to trigger unintended behaviour during deserialisation rather than after normal business logic begins.
That is why the safest posture is to treat every deserialisation boundary as potentially hostile unless the source, schema and object types are tightly controlled. Vendor documentation and secure coding guidance should be used to confirm whether a given serialisation path is intended for trusted-only use.
Security Controls and Safer Design Choices
Controls should focus on reducing what the deserialiser is allowed to reconstruct. Prefer explicit schemas or safer data formats for externally influenced inputs, and keep serialisation libraries away from attacker-supplied payloads wherever possible. If binary serialisation must remain in use, constrain accepted types, isolate the processing path and avoid loading arbitrary application classes during reconstruction.
It also helps to separate internal convenience from external trust. A cache entry, session blob or message payload may be fast to read, but if its origin is not strongly authenticated and validated, the object stream should be treated as untrusted data. The goal is to make deserialisation predictable, narrow and recoverable rather than permissive.
Risk and Threat Considerations
FST Serialization can become dangerous when applications deserialize attacker-influenced input, because the library may reconstruct complex Java objects before the application has a chance to enforce business rules. That creates a classic deserialisation attack surface where gadget chains, logic abuse or integrity poisoning can occur.
Failure mechanism: An attacker supplies a crafted binary payload that causes the application to instantiate unintended classes or execute unsafe code paths during object reconstruction.
Impact: Depending on the surrounding application and reachable gadgets, the result can include application compromise, data manipulation, denial of service or downstream execution of actions the program never intended to expose.
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 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 | Covers validation of untrusted input before it is processed. |
| SA-11 — Developer Testing and Evaluation | Supports testing code paths for deserialisation flaws and unsafe gadget handling. | |
| SI-4 — System Monitoring | Supports detection of anomalous deserialisation behavior and compromise indicators. | |
| Recommendation — Validate serialized input before reconstruction and reject unexpected object content. Test deserialisation paths for unsafe object handling before release. Monitor for unusual deserialisation events and investigate suspicious object streams. | ||
| OWASP ASVS | V15 — Secure Coding and Architecture | Addresses unsafe object construction and trust-boundary design in application code. |
| Recommendation — Redesign serialization boundaries so only trusted data can reach object reconstruction. | ||
| MITRE ATT&CK | T1027 — Obfuscated Files or Information | Serialized payloads can conceal malicious structure inside compact binary form. |
| Recommendation — Inspect compact payloads for hidden malicious structure before processing. | ||
Practitioner Guidance
Why practitioners should care: The key decision is not whether serialisation is fast, but whether the input stream is trustworthy enough to justify object reconstruction. Review every FST Serialization use case as a trust-boundary decision, not as a performance choice alone.
Common misunderstanding: Teams often assume that a binary format is safer than text because it is less readable. In reality, the security question is whether the deserialiser can be reached by untrusted input and whether the object model being rebuilt contains exploitable behaviours.
Practitioner takeaway: If the payload can cross a boundary you do not fully control, treat the deserialisation path as hostile until proven otherwise.
Related resources from NHI Mgmt Group
- How can security teams tell whether serialization risk is actually controlled?
- Why does prompt injection become more serious when serialization is involved?
- What breaks when attacker-shaped LLM output reaches serialization paths in AI frameworks?
- How should organisations respond when a core AI framework serialization flaw is disclosed?
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 18, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org