Skip to main content

Objenesis CVE-2026-116486

| EUVDEUVD-2026-109813 LOW
Symbolic Name not Mapping to Correct Object (CWE-386)
2026-10-26 VulnCheck GHSA-h635-rrqm-4mjq
2.0
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Deploy attacker class with colliding fully-qualified name
  2. Delivery
    Trigger shared Objenesis to instantiate attacker class first
  3. Exploit
    Name-keyed instantiator cache slot poisoned
  4. Execution
    Host requests trusted same-named class
  5. Persist
    Cache returns attacker's instantiator/object
  6. Impact
    Object substitution or ClassCastException DoS

Vulnerability Assessment

Weakness
CWE
Exploitation Conditions

Exploitation requires all of the following, drawn from the advisory: a single shared Objenesis/ObjenesisStd instance (caching is enabled by default) reused across more than one class loader - the library's documented 'create once and reuse' pattern as seen in servlet containers, OSGi, application servers, and plugin hosts; two distinct classes that share the same fully-qualified name but are loaded by different class loaders (e.g. com.shared.AuthContext in two tenants); and the attacker's ability to run code in the same JVM (a co-tenant, uploaded module, or plugin) that reaches objenesis.newInstance for the attacker's same-named class BEFORE the trusted class is instantiated, so the attacker wins the cache slot. Limiting factors that reduce real-world risk: the vector is local (AV:L) - the attacker must already have code execution inside the JVM as a co-tenant; the ordering/race-for-cache-slot and the specific multi-class-loader deployment make it high-complexity (AC:H / AT:P); single-class-loader or single-instance-per-tenant deployments are not affected; and impact is limited to object substitution and a repeatable ClassCastException crash.

Impact

Signals converge on genuinely low real-world priority. The input CVSS 4.0 vector (AV:L/AC:H/AT:P/PR:L/UI:N, all impacts Low) scores 2.0, and the GHSA advisory's own CVSS 3.1 vector (AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:L) scores 4.5 Medium - both agree the flaw is local, high-complexity, needs some privilege, and yields only limited confidentiality, integrity, and availability impact. The vuln.today decision label is 'monitor', consistent with that. No CISA KEV entry is present (not actively exploited) and no EPSS score was supplied, so widespread-exploitation probability cannot be quantified from the data. A reproduced proof-of-concept is published in the GHSA advisory, but PoC availability is not active exploitation. The two CVSS versions differ in headline number (2.0 vs 4.5) but not in substance - both reflect a local, conditional, low-impact issue. Bottom line: this is a real correctness/security defect but not an emergency; it matters only to specific multi-tenant Java deployments and should be patched on a routine schedule rather than treated as an urgent threat.

Exploit ScenarioDerived

In a JVM that reuses one shared ObjenesisStd instance across multiple class loaders (servlet container, OSGi, application server, or plugin host), an attacker-controlled plugin ships its own class bearing the same fully-qualified name as a trusted class and triggers the shared service to instantiate it first, poisoning the name-keyed instantiator cache. When the host later asks the same Objenesis instance for the trusted same-named class, it receives the attacker's instantiator and object (object substitution across the trust boundary), or the host crashes with a ClassCastException denial of service when it casts the value to its own type. A reproduced working proof-of-concept against objenesis-3.5.jar is published in the GHSA advisory.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 26, 2026

Type confusion in Objenesis 3.5 and earlier can make newInstance() return an object of a different same-named class when one cached Objenesis/ObjenesisStd instance is shared across multiple class loaders. A local low-privileged attacker who can execute code in the same JVM as a co-tenant or plugin can win the name-keyed cache slot and cause object substitution across the trust boundary, or a repeatable ClassCastException crash when the caller uses the returned value as its own type. The risk is limited to multi-class-loader deployments that reuse a single cached instance; scores are low (CVSS 4.0 2.0; vendor CVSS 3.1 4.5), no CISA KEV entry or confirmed active exploitation is reported, and the advisory includes a proof-of-concept reproduction.

RemediationAI

Upgrade to Objenesis 3.6, which contains the upstream fix (commit https://github.com/easymock/objenesis/commit/40f90f435a06b16af74a7398f0007faeaa52c00c) replacing the name-keyed ConcurrentHashMap with a ClassValue cache keyed by Class; the vendor advisory is https://github.com/easymock/objenesis/security/advisories/GHSA-743r-26gf-97ff. If upgrading cannot be completed, do not share a single cached Objenesis/ObjenesisStd instance across mutually distrusting class loaders-use a separate instance per tenant/class-loader or disable instantiator caching where the API allows-and treat those as compensating controls only, since any still-shared cached instance retains the name-collision behavior. These workarounds give up the shared instantiator cache's reuse benefit.

Affected VersionsENISA

objenesis 0 <3.6

Affected Packages

euvd objenesis fix: 3.6

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Objenesis is a Java library for instantiating objects without invoking constructors, commonly used by mocking, serialization, dependency-injection, and caching frameworks. In versions before 3.6, ObjenesisBase.getInstantiatorOf() cached ObjectInstantiator values in a ConcurrentHashMap keyed by clazz.getName(), even though JVM class identity is the pair (defining ClassLoader, fully-qualified name). When a single caching Objenesis instance serves multiple class loaders-such as servlet containers, OSGi, application servers, or plugin hosts-two distinct classes with the same binary name collide; the first instantiator placed in the cache is returned for the other class, causing wrong-class object creation and ClassCastException. The vendor maps this to CWE-386 (symbolic name not mapping to the correct object) and type confusion (CWE-843); the upstream fix replaces the String-keyed ConcurrentHashMap with a ClassValue keyed by the Class object. The advisory also identifies a similar name-derived lookup pattern in the exotic module's MagicInstantiator, though the CVE and CPE center on the core cache. The affected package is org.objenesis:objenesis, with CPE cpe:2.3:a:easymock:objenesis:*:*:*:*:*:*:*:*.

Know when Objenesis gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (VulnCheck) PRIMARY 2.0 LOW
CVSS:4.0/AV:L/AC:H/AT:P/PR:L/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N
vuln.today AI 4.5 MEDIUM

Attacker must be a local co-tenant running code in the JVM (AV:L, PR:L) under an unusual shared-instance multi-class-loader setup with cache-ordering dependence (AC:H); object substitution and a ClassCastException crash give low C/I/A.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:L
4.0 AV:L/AC:H/AT:P/PR:L/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
High
Attack Requirements
Present
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Objenesis before 3.6 contains a type confusion vulnerability that allows code in one class loader to substitute objects into another by exploiting instantiator caching keyed on class name. When a shared ObjenesisStd instance caches instantiators by clazz.getName() in ObjenesisBase.getInstantiatorOf(), same-named classes collide, causing newInstance() to return wrong-class objects and ClassCastException failures.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
High
ubiquitous Java transitive dependency via Mockito, Kryo, Spring, EasyMock
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity LOW
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

10
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +10
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy