/

CVE-2026-35482

Severity:

HIGH RISK

(8.0)

Sandbox Escape via Improper Authorization (CWE-863) in alf.io Extension Script Engine

CVE-2026-35482

Awaiting Analysis

Vulnerability type

Category:

Sandbox Escape / Improper Authorization

CWE:

CWE-863

Impact:

Remote Code Execution (from authenticated admin context)

Severity:

HIGH RISK

(8.0)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A sandbox escape vulnerability in the alf.io extension script engine allows an authenticated administrator to break out of the intended JavaScript sandbox and execute arbitrary operating system commands on the server.

The issue stems from an injected Java helper object and incomplete blocking of dangerous JavaScript constructs in the Rhino AST, enabling attackers to leverage Java reflection without triggering validation safeguards.

Affected context

This vulnerability affects alf.io deployments that enable the extension script engine to run custom JavaScript in a Rhino-based sandbox.

It is relevant in environments where:

  • Administrator-level users can create or modify extension scripts
  • The extension engine exposes Java objects to the script environment
  • Script validation is based on AST inspection and blocklists

The risk is most pronounced when the alf.io server runs with high OS-level privileges or has access to sensitive internal systems.

Exploit preconditions

  • Attack surface: Administrative web interface or API that allows managing alf.io extension scripts.
  • Required access: Authenticated access with administrator-level permissions capable of defining or editing extension JavaScript.
  • Trigger point: Execution of a crafted extension script by the alf.io extension engine within the Rhino sandbox.
  • Why exploitation is possible:
  • A Java object (returnClass) is injected into the script context without proper capability restrictions.
  • The AST-based validation relies on an incomplete blocklist that does not cover all reflection-based escape patterns.
  • Combined, these weaknesses allow the script to obtain reflective access to the Java runtime and invoke OS-level commands.

Why this happens

The root cause is a flawed sandbox design that assumes AST-based filtering and a limited set of banned constructs is sufficient to enforce script isolation.

By exposing a Java object (returnClass) directly to the JavaScript environment without strictly limiting its methods, the engine inadvertently provides a bridge into the wider Java runtime.

The AST validation layer attempts to block obvious escape patterns but is incomplete, allowing attackers to construct reflection-based access paths that bypass the blocklist.

This maps to CWE-863: Incorrect Authorization, because the sandbox fails to reliably enforce the intended restriction that extension scripts cannot access privileged Java or OS-level functionality, despite being executed under an administrative user's control.

Potential impact

  • Execution of arbitrary operating system commands under the permissions of the alf.io server process
  • Full compromise of the alf.io application instance and its data
  • Access to sensitive configuration secrets, database credentials, and internal APIs reachable from the server
  • Use of the compromised server as a pivot point for broader network intrusion
  • Integrity breaches such as tampering with event, ticket, or payment-related data

General mitigation guidance

Effective mitigation focuses on hardening the scripting model and reducing the power of exposed objects:

  • Prefer script engines that support default-deny sandboxing with strong isolation guarantees, rather than relying on ad-hoc blocklists.
  • Avoid injecting raw Java objects into the script context; instead expose minimal, purpose-built facades that provide only the methods needed for extensions.
  • Apply capability-based design where scripts can only invoke pre-approved actions, not arbitrary reflection or class loading.
  • Enforce strict validation of scripts using allowlists of safe constructs instead of blocklists of forbidden APIs or patterns.
  • Run the alf.io server with least-privilege OS accounts, limiting the impact of command execution and restricting filesystem and network access where feasible.
  • Implement defense in depth by combining sandboxing with external controls like OS-level mandatory access controls and tight configuration of Java security policies where applicable.

How teams detect issues like this

Organizations can detect and monitor for this class of sandbox escape issues using multiple approaches:

  • Static analysis and code review:
  • Flag any script engines that expose Java objects directly to untrusted or semi-trusted scripts.
  • Review for reliance on blocklist-based sandboxing and use of reflection, class loaders, or unrestricted method invocation from scripts.
  • Check for missing or weak enforcement of Java security managers or equivalent isolation mechanisms.
  • Security testing:
  • Include targeted tests that attempt to access reflection APIs, runtime, process-execution facilities, and file/network I/O from within extension scripts.
  • Use fuzzing or semi-automated script generators to probe for unexpected Java access in the sandbox.
  • Runtime monitoring:
  • Log and alert on suspicious operations originating from the script engine, such as process execution, dynamic class loading, or unexpected file access patterns.
  • Monitor administrative actions related to script creation and modification, and correlate them with unusual system-level activity.
  • Automated review tools:
  • Integrate SAST/IAST tools that recognize patterns of unsafe script sandboxing and highlight direct exposure of powerful Java objects to scripting environments.

Sources

SourceLink
github.comgithub.com/alfio-event/alf.io/security/advisories/GHSA-3w8f-mcf6-cm7h

Frequently asked

questions

Yes, but only through interfaces that allow managing extension scripts. An attacker must reach the alf.io administrative functionality (typically via HTTP/HTTPS) and be able to submit or edit scripts to exploit the flaw.

The attacker must have authenticated administrator-level access within alf.io, or equivalent access to the script management API. Lower-privileged or anonymous users cannot exploit this vulnerability directly under normal configuration.

Replace blocklist-based sandboxing with a strict allowlist of permitted APIs and constructs, expose only narrow, well-audited facades instead of raw Java objects, and ensure the script engine cannot reach reflection, process execution, or class-loading mechanisms. Treat all in-application script execution as untrusted and isolate it accordingly.

Design script extension systems around least privilege and capability-based access, perform thorough threat modeling of the scripting surface, and require security review for any new object or API exposed to scripts. Combine robust sandboxing with strong operational controls such as restricted OS permissions, monitoring of administrative script changes, and automated checks in CI to flag unsafe sandbox patterns.

Find out what's already
exploitable in your codebase.