CVE-2026-108097 Deep Dive: Turning a Drupal Field UI Callback Into RCE

Fortbridge research hero with the Drupal logo: Field UI callback verified, contributed writer not yet identified

Drupal’s SA-CORE-2026-014 (CVE-2026-108097) patched a “critical” remote code execution flaw in the Field UI module. The advisory says core alone can’t reach it and that contributed modules expose it, without naming them. We rebuilt the entire exploit locally, end to end, on real Drupal 11.4.9/11.4.10 pairs: sink, gadgets, file exfiltration, and full command execution. Here’s exactly how it works, what it can and can’t do, and the one piece that’s still missing.

The one line that matters

The vulnerable code is a single line in core’s Field UI table element (FieldUiTable.php:72, ≤ 11.4.9):

$region_name = call_user_func_array($row['#region_callback'], [&$row]);

Field UI tables are render arrays: data. This line treats one field of that data as code: whatever PHP callable is named in a row’s #region_callback is executed, with the row itself as the argument.

In 11.4.10 the line is gone: the region is read from a plain declared value. That deletion is the entire fix, and it’s why every exploit variant dies on the patched site regardless of what feeds it.

Two halves of an exploit

  • The sink (core): the line above. Present in every stock 11.4.9 install.
  • The writer (contrib/custom code): something must let an HTTP actor influence a row’s #region_callback. Core alone doesn’t: the only core field_ui_table sits on the admin-gated Manage Display form (unauthenticated → 403, rows carry compile-time-fixed callbacks, verified). The advisory says contributed modules expose this, at least one without authentication, but names none.

That split is exactly why the advisory scores Critical 19/25 rather than maximum: the vulnerable code ships everywhere, but reachability depends on the module ecosystem.

The lab

Paired, isolated Docker sites on loopback: 11.4.9 (vulnerable) and 11.4.10 (patched), real Drush-installed Drupal with Field UI enabled, installed files hash-matched to upstream release tags.

Every claim below is an affected-vs-patched differential over unauthenticated HTTP. Because no genuine writer module is publicly known, a small lab-only bridge module supplies the missing writer (it maps a request choice to a row callback); we label it synthetic everywhere it appears.

Everything the sink then executes is stock Drupal/PEAR/PHP code (PEAR’s System class ships with drupal/core-recommended, so the gadgets exist in every default install).

What can the callback be? We enumerated all of them

The callback receives the row array as its only argument, which kills the classic string-argument gadgets (system($row) → TypeError; verified).

The genuine exploit shape is therefore a callback that interprets row content, verified dynamically with an allowlisted lab callback running whoami (11.4.9 only).

So we enumerated every function and public static method in the full install: 9,934 classes → 5,715 callable candidates → 2,109 invocable with this exact signature, and dynamically probed all of them.

Seven dangerous gadgets survived adjudication. The interesting ones:

  • PEAR System::cat: file read/copy; with a > element, file write
  • PEAR System::rm: file delete
  • print_r / dd / VarDumper::dump: response-side disclosure
  • Webform’s submitFormValues: conditional DB content-injection

The weaponization ladder

1. Arbitrary-callable capability

Row callback = the string print_r → the vulnerable site’s response is the row dump, request nonce included. Patched site: normal render, zero matches.

print_r row dump in the Drupal 11.4.9 response: the row #region_callback string was executed, request nonce visible in the dump

2. Critical-file disclosure

System::cat copying settings.php into the public files directory, then a plain GET; the response serves the site’s hash_salt and database credentials. Two unauthenticated requests.

settings.php served over unauthenticated HTTP on Drupal 11.4.9: hash_salt and database lines in the response body

3. Full RCE: upload, replace, execute

Two layers stand between the sink and code execution in the files directory: its own .htaccess turns the PHP engine off (php_flag engine off), and Drupal’s webroot .htaccess blocks direct .php access. Deleting the first layer is not enough; the second one holds.

The bypass is replace, not delete. A subdirectory .htaccess with its own RewriteEngine On does not inherit the parent’s rewrite rules, so a crafted replacement re-enables PHP in files/ and drops the parent’s block in one move.

And nothing needs to be planted on disk beforehand: we staged both payloads through Drupal’s own upload path: a stock webform with a file element, open to unauthenticated users, private-files default. Drupal renames .php uploads to .php_.txt, which does not matter: System::cat copies content, and the destination name is ours to choose.

Three rows, fired in a single unauthenticated request:

  1. System::cat: copy the uploaded marker to files/x.php
  2. System::rm: delete files/.htaccess
  3. System::cat: copy the uploaded .htaccess over it (RewriteEngine On + php_flag engine on)

Then a GET of the marker executes it:

Full RCE on Drupal 11.4.9: three-row chain writes marker, replaces .htaccess, GET executes id and whoami as www-data

4. What didn’t work (and why)

  • Direct read-to-response isn’t available: System::cat returns, never echoes; the copy-to-web-tree path is the read.
  • /proc/self/environ exfiltration is kernel-blocked (the setuid Apache worker loses its dumpable flag).
  • Cron/SSH-key escalation is permission-walled: the write primitive reaches only www-data-writable paths (files/, /tmp, module/theme dirs).
  • On nginx/php-fpm deployments the .htaccess layers don’t exist at all: there the answer depends entirely on server config (Drupal’s recommended nginx config blocks files-dir PHP, but that’s a choice, not a guarantee).

How critical is it, really?

Depends which ruler you use, and they disagree about exactly one question: does “nobody can currently name the path” count as mitigation?

  • CVSS 3.1, scored as exploitable (the advisory’s assumption: a writer module exists): AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H = 9.8 Critical.
  • CVSS with the contrib dependency modeled as attack complexity (AC:H): 8.1 High: exploitation depends on a condition beyond the attacker’s control (an unspecified module being installed).
  • Drupal’s own calculator: Critical 19/25 (AC:Basic / A:None / CI:All / II:All / E:Theoretical / TD:Default), the top edge of Critical, one point below Highly Critical. The E:Theoretical input (“no public exploit exists”) is doing real work in that score, and it is the thing our lab work speaks to directly.

Our read: the moment a genuine writer module is publicly named, every mitigating reading evaporates: this is a 9.8 Critical. That discount holds only until a module gets named.

What’s still missing

The one piece we couldn’t find is the writer: a real module that feeds request data into a row’s #region_callback.

We looked hard. We checked 117 candidate modules against their source, ran an engine-exhaustive public code search, diffed every contrib security release in the advisory window, and shallow-cloned 250 projects from the canonical contrib corpus.

All came back empty, with a telling twist: no public contrib module uses this pattern at all. The only one that ever did is Entity List, fixed under SA-CONTRIB-2026-218.

There’s no breakage trail either: three days after release, not one “11.4.10 broke my display table” issue exists anywhere in Drupal’s queues, which is what a real user base would have produced.

So when the advisory says “multiple serious exploit paths exist with contributed modules”, the reading that fits the evidence is entity_list plus custom code: your real exposure likely lives in bespoke modules written for your own site, not in anything you can download.

What defenders should do

  1. Patch to 11.4.10 (or the parallel fixed lines): it’s the whole ballgame. The sink was removed there, so no module can reach it.
  2. Audit contrib/custom modules for anything writing request- or submission-derived data into render-array rows of field_ui_table (grep for region_callback, field_ui_table, tablePreRender).
  3. Treat the files directory as hostile: keep the stock .htaccess (Apache) or the PHP-deny location block (nginx), and alert on any change to files/.htaccess: our chain replaces it mid-request.
  4. Watch for unexpected files appearing under sites/default/files/: a copied settings.php or a new .php there is a strong IoC.

Code & evidence: github.com/fortbridge/cve-2026-108097-research: the lab, the bridge module, the witness suites, the gadget inventory, and the evidence logs.

About Post Author