Drupal Core’s 18 November 2026 Security Release: A Practical Incident-Ready Update Runbook

Tim Rabbetts | November 19, 2026

Drupal site owners have just had one of the releases that deserves immediate operational attention rather than a routine “run Composer when convenient” response. On 18 November 2026, the Drupal Security Team published a critical core advisory describing a remote-code-execution vulnerability involving the Drupal installer, alongside a moderately critical advisory concerning a gadget chain that can become useful when another insecure deserialisation weakness exists. ([drupal.org](https://www.drupal.org/security))

This article is a deployment and incident-response runbook for technical teams maintaining Composer-managed Drupal sites. It covers the supported fixed versions, safe update sequencing, temporary containment when an immediate patch is difficult, post-update validation and the checks worth performing if a site may already have been targeted. The central message is simple: patch first, then investigate with evidence. Do not treat a security release as an ordinary dependency refresh.

What was fixed on 18 November 2026?

The critical issue is tracked as SA-CORE-2026-017 and CVE-2026-132165. Drupal core includes install.php, and under specific conditions an attacker can use the installer to attempt to reinstall Drupal. The advisory states that this can lead to site takeover or remote code execution. The issue is rated critical by Drupal’s own risk scale and is particularly concerning because the vulnerable functionality is associated with installation rather than an authenticated editorial workflow. ([drupal.org](https://www.drupal.org/security))

The second issue, SA-CORE-2026-018 and CVE-2026-132166, concerns a chain of methods in Drupal core that could be used as a gadget chain when an insecure deserialisation vulnerability exists elsewhere in the application. Drupal explicitly says that this issue is not directly exploitable on its own. It should nevertheless be patched because gadget chains are pieces of an attack path: they can increase the impact of a separate vulnerability in contributed code or custom code. ([drupal.org](https://www.drupal.org/security))

The fixed releases are:

  • Drupal 11.3.22 for sites on the 11.3 branch.
  • Drupal 11.4.13 for sites on the 11.4 branch.
  • Drupal 10.6.22 for sites on the 10.6 branch.

Drupal’s release notes also state that Drupal 11.2.x and below, together with Drupal 10.5.x and below, are end-of-life and do not receive security coverage. The 11.3.22 release contains no other fixes besides the listed security updates, although new installations also receive a change to how the installer handles a non-writable settings.php. ([drupal.org](https://www.drupal.org/project/drupal/releases/11.3.22))

Start with an accurate inventory

Before changing anything, establish exactly which code is deployed and where. A common failure mode during emergency patching is updating a local checkout or staging environment while production runs from a different branch, a different release directory or a manually copied codebase.

From the Drupal project root, record the current state:

git status --short
git branch --show-current
git log -1 --oneline
composer show drupal/core-recommended drupal/core-composer-scaffold drupal/core-project-message
vendor/bin/drush status

For a Composer-managed project, the three core packages normally worth checking are drupal/core-recommended, drupal/core-composer-scaffold and drupal/core-project-message. The exact package layout can vary, so inspect composer.json rather than assuming that every project uses the same constraints.

Also confirm the running version through Drupal or Drush rather than relying only on the lock file:

vendor/bin/drush status --fields=drupal-version,uri,root
composer show drupal/core-recommended --format=json

If your deployment process builds an artefact in CI and copies only selected directories to production, check the artefact manifest as well. The important question is not “has someone run Composer?” but “which exact code is serving requests right now?”

Take a controlled backup before updating

A backup is not a substitute for a tested rollback, but it gives you a recovery point if the update exposes an unrelated problem in custom code, contributed modules or infrastructure.

At minimum, capture:

  • The database.
  • settings.php and any environment-specific configuration outside version control.
  • The files directory, especially if uploaded files are not stored separately.
  • The current deployed code revision or release artefact.
  • Relevant web server, PHP-FPM, database and application logs.

For example, a database export might look like this on a MySQL or MariaDB system:

mysqldump \
  --single-transaction \
  --routines \
  --triggers \
  --no-tablespaces \
  --result-file=/var/backups/example-$(date +%Y%m%d-%H%M%S).sql \
  example_database

Use the database tooling and options appropriate to your platform. Do not copy this command unchanged into a PostgreSQL environment, and do not assume that a successful SQL dump includes object storage, private files or external search indexes.

Verify that the backup is readable and that the destination is protected. A backup containing credentials, personal data or private files should not be left in a publicly served directory.

Preferred update method: Composer

Drupal’s release page provides the Composer update pattern for the fixed 11.3.22 release: update the core packages together and allow their dependencies to move within the constraints defined by the project. ([drupal.org](https://www.drupal.org/project/drupal/releases/11.3.22))

If the project is already on Drupal 11.3.x, the targeted command is:

composer require \
  drupal/core-recommended:11.3.22 \
  drupal/core-composer-scaffold:11.3.22 \
  drupal/core-project-message:11.3.22 \
  --update-with-all-dependencies

For Drupal 11.4.x, replace all three version constraints with 11.4.13. For Drupal 10.6.x, use 10.6.22. Do not blindly use the 11.3 command on a project that is constrained to another minor branch.

After Composer resolves the update, inspect the proposed changes before committing:

git diff -- composer.json composer.lock
git diff --stat
composer audit

The audit command is useful for detecting known vulnerabilities in the complete PHP dependency graph, but it does not replace reading the Drupal advisory or testing the application. A clean dependency audit does not prove that a deployed application has not been compromised.

In a normal repository-based workflow, commit the lock-file and scaffold changes, build the same artefact used by your deployment pipeline and promote that artefact through staging and production. Avoid running an improvised Composer update directly on a production server if your normal process is immutable or release-based.

Test the update before production

The security update is deliberately narrow, but production systems often contain assumptions that are not represented in the core test suite. Run the tests that reflect your own application:

  • Log in as an administrator and at least one ordinary authenticated role.
  • Create, edit and publish representative content.
  • Exercise media uploads and private-file downloads.
  • Check multilingual routes if the site is translated.
  • Test JSON:API, GraphQL or custom endpoints where applicable.
  • Run the deployment’s automated functional and integration tests.
  • Check queue workers, cron, search indexing and scheduled jobs.

Clear caches after the new code is active:

vendor/bin/drush updatedb:status
vendor/bin/drush updb -y
vendor/bin/drush cr
vendor/bin/drush status

For this particular release, do not expect a database update simply because the package version changed. updatedb:status is still a useful deployment check, and the command sequence remains appropriate when the project includes pending database updates from other modules.

If the site uses multiple web nodes, verify that every node is running the same release. A load balancer can make a partially deployed cluster appear intermittently broken, and it can also leave one node exposed after another node has been patched.

Temporary containment when patching is delayed

The correct response is to upgrade. Temporary controls are only for buying time while a maintenance window, deployment approval or emergency change is arranged.

First, consider taking the site out of public service or placing it behind an access-controlled maintenance layer. Drupal maintenance mode can reduce normal application access, but it should not be treated as a complete web-server security boundary:

vendor/bin/drush state:set system.maintenance_mode 1
vendor/bin/drush cr

For a site that must remain available, restrict access to the installer path at the web server or upstream proxy. A simple Nginx location rule could be used as a temporary control:

location = /install.php {
    allow 192.0.2.10;
    deny all;
}

Replace the example address with an approved administrative source, and reload the configuration through your normal change process. If the site is behind a reverse proxy, enforce the restriction there as well as at the origin where practical.

Apache deployments can use an equivalent access rule, but the exact syntax depends on whether the server uses Apache 2.4 authorisation directives, a virtual-host configuration or per-directory .htaccess rules. Test the rule against the actual public URL and confirm that it returns the intended status code.

Do not delete install.php as an improvised fix. It is part of the Drupal codebase, and removing files from a Composer-managed installation creates drift that can complicate the proper update. Restricting access may reduce exposure temporarily, but only the fixed core release addresses the underlying defect.

Check for signs of attempted exploitation

The advisory does not mean that every affected site has been compromised. It does mean that teams should preserve relevant evidence rather than updating and immediately deleting the logs that could help answer what happened.

Before rotating or truncating logs, retain copies of:

  • Web access and error logs covering the period before the advisory and the period after patching.
  • PHP-FPM or application worker logs.
  • WAF, reverse-proxy and load-balancer logs.
  • Authentication and administrative activity logs.
  • Deployment records and file-integrity alerts.

Start with requests to the installer and unusual requests for PHP files. The following is only a triage example for common access-log formats:

grep -Ei 'install\.php|update\.php|authorize\.php' /var/log/nginx/access.log

grep -Ei '\.(php|phar)(\?|$)' /var/log/nginx/access.log \
  | grep -Ev '/index\.php'

find web/sites -type f -mtime -14 -printf '%TY-%Tm-%Td %TH:%TM %p\n' \
  | sort

These searches are indicators, not proof. A legitimate administrator or automated scanner may request some of the same paths, and an attacker may use a route that does not match a simple search expression.

Look for changes that cannot be explained by a deployment:

  • New PHP files in public, private or temporary file locations.
  • Unexpected changes to settings.php, service definitions or trusted-host configuration.
  • New administrator accounts or unexpected role assignments.
  • Changes to scheduled jobs, queue consumers or deployment credentials.
  • Modified Composer files or lock files outside the release process.
  • Unexpected outbound requests from the web or PHP processes.

If compromise is plausible, involve the organisation’s incident-response process. Preserve the original host or volume where possible, isolate rather than destroy evidence, rotate credentials from a clean environment and assess whether database or personal data access occurred. Reinstalling the application from a known-good artefact may be safer than attempting to clean unknown modifications in place.

Do not overlook end-of-life branches

The November release also exposes a lifecycle problem for sites that have deferred minor-version upgrades. Drupal 11.3.x and 10.6.x are the final supported branches for their respective lines in this release window, while older branches do not receive security coverage. Drupal’s release notes explicitly mark Drupal 11.2.x and below, and Drupal 10.5.x and below, as end-of-life. ([drupal.org](https://www.drupal.org/project/drupal/releases/11.3.22))

Drupal’s published schedule says that security support for Drupal 11.3.x and 10.6.x ends in December 2026 when Drupal 11.5.0 and Drupal 12.0.0 are released. The same schedule places Drupal 12.0.0 in the week of 7 December 2026. ([drupal.org](https://www.drupal.org/about/core/policies/core-release-cycles/schedule))

That makes this a poor moment to postpone branch planning. If a site is still on 10.5.x or an older 11.x minor, the immediate objective is to move to a supported release, not merely to document the exception. If the site is on 10.6.x, update to 10.6.22 now and plan the major-version migration separately.

Prepare for shorter minor-version support windows

Drupal announced on 2 November 2026 that minor versions will receive eight months of overlapping security coverage from 2027 rather than the previous twelve months. The change is intended to reduce backporting work and align more closely with upstream Symfony releases. Drupal major versions will still be supported for at least four years, but teams will have less time to remain on an older minor branch. ([drupal.org](https://www.drupal.org/psa-2026-11-02))

This changes the operational maths for site owners. A quarterly patching habit may no longer be sufficient if it leaves a site several months behind its current minor release. Establish a recurring process that includes:

  • Watching Drupal security advisories and release windows.
  • Testing core updates in a representative environment.
  • Maintaining a short-lived patch branch or update pull request.
  • Recording the exact production commit and package versions.
  • Practising rollback and restoration rather than assuming they work.
  • Scheduling minor-version upgrades before the final security-only period.

Drupal’s regular security release window is normally the third Wednesday of the month, although the project can publish a public service announcement for exceptional releases. The published schedule advises teams to watch the window and be ready to update supported branches. ([drupal.org](https://www.drupal.org/about/core/policies/core-release-cycles/schedule))

A compact post-deployment checklist

Once the fixed release is live, record the outcome rather than relying on an informal message in a team channel:

  1. Confirm the production code reports the fixed Drupal version.
  2. Confirm every web node, worker and cron host uses the same release.
  3. Confirm the deployment completed successfully in the monitoring system.
  4. Clear Drupal caches and restart workers if the platform requires it.
  5. Run smoke tests for anonymous pages, login, editorial forms and APIs.
  6. Review error rates, response times and authentication events.
  7. Check logs for requests to the installer before and after patching.
  8. Remove temporary access restrictions only after the fixed code is verified.
  9. Document whether any suspicious activity was found.
  10. Open follow-up work for branch upgrades, credential rotation or hardening.

For regulated or high-risk environments, include the advisory identifiers, CVE identifiers, affected asset list, timestamps, fixed versions and approval references in the change record. This makes the response auditable and gives the next engineer enough context to understand what was changed.

Conclusion

The 18 November 2026 Drupal core release should be handled as an urgent security change. Update Drupal 11.3.x sites to 11.3.22, Drupal 11.4.x sites to 11.4.13 and Drupal 10.6.x sites to 10.6.22, using the project’s normal Composer and deployment workflow. ([drupal.org](https://www.drupal.org/project/drupal/releases/11.3.22))

If an immediate deployment is impossible, restrict exposure and preserve evidence, but do not mistake maintenance mode or a web-server rule for a permanent fix. After patching, verify every node, inspect the relevant logs and use the incident-response process if the evidence suggests attempted exploitation. With Drupal 12 approaching and shorter minor-version support windows taking effect, the long-term lesson is equally important: security patching needs to be a tested delivery capability, not an emergency activity invented after an advisory lands.