CVE-2026-29080

A SQL injection vulnerability in 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). On Oracle deployments attacker-controlled filter keys and values are interpolated directly into sqlalchemy.text() via Python .format(), completely bypassing parameterization. This enables full database compromise including extraction of authentication tokens, password hashes, and all managed data identifiers. This affects versions 1.27.0 and later before 35.8.5, 38.5.5, 39.4.2, and 40.1.1.

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. 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.

Any authenticated Rucio user can exploit this through the DID search API to execute arbitrary SQL against the backend database. This can expose all managed data identifiers and sensitive tables such as identities, tokens, accounts, rse_settings, and rules, and may allow modification of database contents. The issue affects Oracle deployments using the default json_meta plugin and does not affect PostgreSQL or MySQL deployments using that plugin.

This vulnerability has been fixed in versions 35.8.5, 38.5.5, 39.4.2, and 40.1.1.

A SQL injection vulnerability in 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). On Oracle deployments attacker-controlled filter keys and values are interpolated directly into sqlalchemy.text() via Python .format(), completely bypassing parameterization. This enables full database compromise including extraction of authentication tokens, password hashes, and all managed data identifiers. This affects versions 1.27.0 and later before 35.8.5, 38.5.5, 39.4.2, and 40.1.1.

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. 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.

Any authenticated Rucio user can exploit this through the DID search API to execute arbitrary SQL against the backend database. This can expose all managed data identifiers and sensitive tables such as identities, tokens, accounts, rse_settings, and rules, and may allow modification of database contents. The issue affects Oracle deployments using the default json_meta plugin and does not affect PostgreSQL or MySQL deployments using that plugin.

This vulnerability has been fixed in versions 35.8.5, 38.5.5, 39.4.2, and 40.1.1.

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:

1. HTTP input (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.

2. Plugin routing (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).

3. FilterEngine initialization (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.

4. Value typecasting (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.

5. Sanity checks (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.

6. SQL construction (filter_engine.py:536-554): On Oracle, the unsanitized key and value strings are interpolated directly into text() via .format().

7. SQL execution (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…

A SQL injection vulnerability in 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). On Oracle deployments attacker-controlled filter keys and values are interpolated directly into sqlalchemy.text() via Python .format(), completely bypassing parameterization. This enables full database compromise including extraction of authentication tokens, password hashes, and all managed data identifiers. This affects versions 1.27.0 and later before 35.8.5, 38.5.5, 39.4.2, and 40.1.1.

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. 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.

Any authenticated Rucio user can exploit this through the DID search API to execute arbitrary SQL against the backend database. This can expose all managed data identifiers and sensitive tables such as identities, tokens, accounts, rse_settings, and rules, and may allow modification of database contents. The issue affects Oracle deployments using the default json_meta plugin and does not affect PostgreSQL or MySQL deployments using that plugin.

This vulnerability has been fixed in versions 35.8.5, 38.5.5, 39.4.2, and 40.1.1.

A SQL injection vulnerability in 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). On Oracle deployments attacker-controlled filter keys and values are interpolated directly into sqlalchemy.text() via Python .format(), completely bypassing parameterization. This enables full database compromise including extraction of authentication tokens, password hashes, and all managed data identifiers. This affects versions 1.27.0 and later before 35.8.5, 38.5.5, 39.4.2, and 40.1.1.

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. 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.

Any authenticated Rucio user can exploit this through the DID search API to execute arbitrary SQL against the backend database. This can expose all managed data identifiers and sensitive tables such as identities, tokens, accounts, rse_settings, and rules, and may allow modification of database contents. The issue affects Oracle deployments using the default json_meta plugin and does not affect PostgreSQL or MySQL deployments using that plugin.

This vulnerability has been fixed in versions 35.8.5, 38.5.5, 39.4.2, and 40.1.1.

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:

1. HTTP input (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.

2. Plugin routing (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).

3. FilterEngine initialization (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.

4. Value typecasting (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.

5. Sanity checks (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.

6. SQL construction (filter_engine.py:536-554): On Oracle, the unsanitized key and value strings are interpolated directly into text() via .format().

7. SQL execution (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…

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

Will follow in two weeks (2025-05-19).

Impact

Vulnerability type: SQL Injection (CWE-89)

Who is impacted:

• All Oracle-based Rucio deployments using the default metadata plugin configuration (json_meta).
• Not affected are PostgreSQL/MySQL deployments using the default json_meta plugin (SQLAlchemy parameterizes the JSON path operations via bind parameters on non-Oracle dialects).

What an attacker can do:

• Full database read access: Extract any table including identities (password hashes and salts), tokens (active authentication sessions), accounts (user enumeration), rse_settings (storage endpoint credentials), and rules (data management policies).
• Password hash extraction: Combined with Rucio's use of single-iteration SHA-256 for password hashing (no KDF), extracted hashes can be cracked at GPU speed.
• Authentication token theft: Active bearer tokens can be extracted and used for immediate session hijacking.
• Data modification: Oracle PL/SQL enables INSERT/UPDATE/DELETE operations via DML within subqueries and PL/SQL blocks.
• Potential remote code execution: Via Oracle's UTL_HTTP, DBMS_SCHEDULER, or Java stored procedures if the database user has elevated privileges.

Required attacker privileges: Any authenticated Rucio user. Authentication tokens can be obtained via any supported method (userpass, x509, OIDC, SAML, SSH, GSS). No special roles or administrative permissions are required. The GET /dids/<scope>/dids/search endpoint is available to all authenticated users.