Skip to main content
Platform security guideReviewed

Drupal security: advisories, end-of-life dates and the permissions your site hands out

The Drupal Security Team publishes advisories for security problems in Drupal core and in contributed projects covered by its advisory policy.

Roles, text formats, web services, file storage and settings.php are set by the people who run each site. This guide shows how to read an SA-CORE or SA-CONTRIB advisory against your installed versions, which release series receive security fixes, and what drupal.org documents for each of those settings, then gives you a register and role permission matrix to fill in for your own site.

Drupal advisory register and role permission matrix

A four-part register to copy for each site: core version and support dates (Part A, eight lines); one line per project, custom module and external library (Part B, four lines); a log of eight drupal.org advisories read on 14 November 2026 (Part C); and a role permission matrix (Part D, ten blocks) covering restricted permissions, text formats, user 1, REST, JSON:API, public and private files, update access, trusted host settings, file ownership and development tools. Parts A, B and D only read and write down what they find: no line alters a setting or exposes a secret value.

drupal.txt

Introduction15 lines

DRUPAL CORE AND MODULE ADVISORY REGISTER, WITH A ROLE PERMISSION MATRIX TEMPLATE. Copy Parts A, B and D into a spreadsheet, a ticket or a shared document, one copy per site and environment. Part C is a log of the eight drupal.org security advisories opened for this guide on 14 November 2026. It is not a complete list. Newer advisories, and older ones not listed here, are on the Security advisories page at https://www.drupal.org/security, which can show Drupal core, contributed projects or public service announcements on their own. RULES FOR EVERY LINE - Each line in Parts A, B and D is a read-only check by the site owner, or a developer they engage, on a site the owner controls: read a screen, a drupal.org page, a report, a file or a command's printed output, or ask your host or developer. Nothing here asks you to change a permission, install or uninstall a module, edit settings.php or services.yml, run update.php or rebuild.php, clear a cache, or send test requests to any site. - Read each role from its Edit role page. Do not sign in as other users or create accounts to fill in the matrix. - settings.php holds the database user name and password, and hash_salt is the salt for one-time login links, cancel links, form tokens and more. For these, write only whether a value is set and where it is loaded from. Never copy a password, salt, key or token into this register, and do not run anything that prints them. Source: drupal.org, Securing file permissions and ownership (the user name and password to connect to the database are stored in settings.php); default.settings.php, Drupal core 11.x branch (hash_salt). - If a line cannot be answered, enter "unknown" and carry it into that part's findings. - Each "Source" line credits the page or file behind a line: where a value is kept, or what it means. Anything marked "this page's advice" is this guide's own recommendation, not a statement from drupal.org. Site: Environment (production or staging): Filled in by (name and role): Date:

Where Drupal sits in your website

A Drupal site runs Drupal core, contributed modules and themes downloaded from drupal.org, custom modules and themes written for that site, and any external libraries those modules ask for.

Where the site is built with Composer, drupal.org's guide to file permissions describes the layout the drupal/recommended-project package creates: index.php and the core directory sit in a folder named web, which is the web root, while composer.json, composer.lock and the vendor directory sit in the project root above it.

The same guide notes that the user name and password each site uses to connect to its database are stored in settings.php.

drupal.org treats these differently. The Drupal Security Team issues advisories for Drupal core and for contributed projects that have opted in to security advisory coverage, and a covered project shows a grey shield icon and the note "Stable releases for this project are covered by the security advisory policy." on its project page.

Its advisory policy says advisories are only issued for projects hosted on drupal.org, and that none will be issued for external libraries or plugins, even when a contributed project requires one. On this page's reading, custom code kept off drupal.org gets no advisory either.

Everything else a site needs is configuration: which roles exist and what each may do, which text formats each role may use, whether the web service modules accept writes, where uploaded files are stored and who may download them, and the values in settings.php. Those are set by whoever builds and runs the site, and installing a security release is a separate job from reviewing them.

This guide was written from drupal.org documentation, the Drupal User Guide, files from Drupal core's 11.x branch, the core release schedule, the Drupal Security Team's advisories and Composer's command-line documentation, all read on 14 November 2026. Several of the documentation pages were written for earlier releases, and the guide says so where it matters.

Is Drupal secure? What drupal.org says it covers and what it leaves to each site

This guide does not rate Drupal, and drupal.org warns against one shortcut to a rating.

Its "Is Drupal secure?" page says the absolute number of security advisories, especially when contributed projects are included, is a number without meaning and should not be used for the purpose of comparison, and that an advisory may be issued for a relatively minor issue.

The same page says issues such as injection, cross-site scripting, session management and cross-site request forgeries have standard solutions in the Drupal API. It says members of the security team sometimes analyse core or contributed code, but that in general the team does not review core or contributed code.

And it says professional security audits of Drupal sites have generally found the vast majority of security holes in the custom theme or modules written by that site's developers, code that did not get the public scrutiny that code on drupal.org receives, and that problems at the server level, such as insecure protocols like FTP, are more likely to be the means of a successful attack than a vulnerability in Drupal, especially in Drupal core.

Where the advisory process stops

The Drupal Security Team's advisory policy sets out what its advisories do not cover, and when none is required. The list is why the register on this page records custom code, external libraries and permissions as well as version numbers:

  • Sandbox projects, projects hosted in external repositories such as some distributions, and contributed projects that have not opted in to coverage.
  • Development releases, alphas, betas and release candidates of contributed projects. For those projects, advisories are only made for issues affecting stable releases in supported major version branches.
  • External libraries and plugins, even when a contributed project requires you to install one, whatever method was used to install it, Composer included. Libraries that Drupal core ships with, such as jQuery, are covered, because that code is hosted on drupal.org.
  • Anything not hosted on drupal.org, since advisories are only issued for projects hosted there. On this page's reading, that takes in custom modules and themes kept off drupal.org.
  • Flaws whose exploit requires one of a listed set of permissions, among them Administer permissions, Administer users and Administer site configuration, or any permission defined with restrict access set to TRUE. For these the policy says no advisory is required, because a user with one of these permissions can already take over the site or bypass various access restrictions on the site.

Drupal security updates: finding and reading an advisory

Advisories are published on the Security advisories page at drupal.org/security, which can show advisories for Drupal core only, contributed projects only, or public service announcements (PSAs) only.

Core advisories carry ids such as SA-CORE-2026-014, and contributed project advisories ids such as SA-CONTRIB-2026-331. The core release schedule says core security release windows begin at 1200 America/New York and will usually be on the third Wednesday of the month, that not every window includes a core security release, and that in rare cases a security release may be published outside the windows, with a public service announcement before it.

The advisory policy adds that the team may occasionally announce an upcoming release in a public service announcement on the Monday before a Wednesday release, for highly critical or critical issues it feels might be easily turned into automated attacks.

Every advisory in this guide's log carries the fields described here, and some add others, such as an update note. "Affected versions" gives the vulnerable ranges in a compact notation, such as <10.5.12 || >=10.6.0 <10.6.11 || >=11.2.0 <11.2.14 || >=11.3.0 <11.3.12 || 11.0.* || 11.1.* for SA-CORE-2026-007.

The solution names the release to install for each supported branch, and the core advisories also say which branches are end-of-life. The description says which part of Drupal or which module is affected and, where there is one, the condition that limits who is affected; three advisories in the log introduce it with "This vulnerability is mitigated by the fact that".

This page's advice is to take versions from the "Affected versions" field, take fixed releases from the solution, and read the condition against your own site before deciding whether an advisory applies.

Reading the security risk line

The "Security risk" field gives a level, a score out of 25 and a string of metric codes. Drupal's page defining security risk levels says the score comes from a risk calculator based on the NIST Common Misuse Scoring System, with 0 to 4 Not Critical, 5 to 9 Less Critical, 10 to 14 Moderately Critical, 15 to 19 Critical and 20 to 25 Highly Critical.

The A code is the privilege level an exploit needs: A:None is all or anonymous users, A:User is user-level access with basic or commonly assigned permissions, and A:Admin is administrator level, broad permissions where restrict access is set to false.

TD, target distribution, runs from TD:All (all module configurations are exploitable) to TD:Uncommon (only uncommon module configurations are exploitable), and E describes whether exploit code is known, where E:Exploit means documented or deployed exploit code already in the wild.

This page's register copies the A code for every match, so the match can be read beside the role permission matrix.

Hearing about releases

drupal.org documents several ways to hear about a release:

  • The Drupal User Guide says highly critical security announcements are displayed on the administration pages of your website, with a link to the announcement on drupal.org.
  • Reports > Available updates > Settings takes the email addresses to notify when updates are available, and whether to check daily or weekly. drupal.org's "Securing your site" page asks for a real email address there, not a test address.
  • The security announcements newsletter is joined from the Edit > My newsletters tab of a drupal.org user profile, and RSS feeds cover core security updates, contributed project updates and public service announcements.
  • The Update Status module does the checking during cron runs and sends drupal.org anonymous usage statistics: a unique key and the list of versions the site runs. Its documentation says it was called Update Manager from Drupal 7 to 11.1, and that from Drupal 11.2 the parts that installed and updated modules were removed, because they did not work with Composer, and the module was renamed back to Update Status. Some drupal.org pages, including "Securing your site", still use the Update Manager name.

Which Drupal versions receive security fixes, and when each reaches end of life

The Drupal core release schedule, which says it is maintained by the core release managers, sets the dates.

Read on 14 November 2026, its end-of-life table listed Drupal 10 with an end-of-life date of 9 December 2026, Drupal 11 with early December 2028, and Drupal 12, given a release date of 9 December 2026, with early December 2030.

The schedule says each major version is supported for between 4 and 4.5 years, that no new releases of a major version are made after its end-of-life date, and that Drupal 10.6.x is the last minor version of Drupal 10.

Its past milestones put the end of life of Drupal 8 at 17 November 2021, Drupal 9 at 1 November 2023 and Drupal 7 at 5 January 2025.

Within a supported major version, only some minor branches receive advisories. The advisory policy says that since Drupal 8.6.0 two minor versions at a time receive security advisories, the most recent minor and the previous minor, and gives the example that Drupal 11.3.x continues receiving them until Drupal 11.5.0 is released.

A public service announcement from the Drupal Security Team dated 2 November 2026, PSA-2026-11-02, says that beginning in 2027 Drupal minor versions will receive 8 months of overlapping security coverage rather than 12, and that major versions of Drupal core will still be supported for at least four years.

On 14 November 2026 the schedule's Monthly table listed the security release window for 11.4.x, 11.3.x and 10.6.x.

Its current development cycle gave the week of 7 December 2026 as the end of security support for 11.3.x and 10.6.x, and its next development cycle gave 21 April 2027 as the last day of security support for 11.4.x.

The advisories show what end of life means in practice. SA-CORE-2026-014, dated 14 October 2026, says Drupal 11.2.x and below, and Drupal 10.5.x and below, are end-of-life and do not receive security coverage. SA-CORE-2026-004 did include releases and patches for unsupported versions, and says they were provided as a best effort due to that issue's severity and that those versions will still have other, previously disclosed security vulnerabilities.

This page's reading: a site on a branch outside the security release window cannot count on a release for the next advisory, which is why the register records the branch as well as the version. Read the schedule again on the day you fill the register in.

Drupal vulnerability checks: matching installed versions to advisories

The installed versions show up in the following places.

The Status report, at Reports > Status report (admin/reports/status), is where the Drupal User Guide says to verify the version of the core software after an update. The Update Status module periodically checks core, contributed modules and themes for new versions, and its results sit under Reports > Available updates.

On a site built with Composer, the composer audit command checks the installed packages against dependency policies, security advisories among them, according to Composer's documentation, which adds that --locked takes the packages from the lock file, whatever the vendor folder holds. drupal.org's "Securing your site" page says you can run composer audit regularly from a cron-triggered script as a supplement to the Update module, and that its example watches all dependencies, not just modules.

A version inside an advisory's range is where the check starts. Several advisories in the log state a condition. SA-CORE-2026-004 says its SQL injection only affects sites using PostgreSQL, while the third-party dependency updates in its releases apply to all sites.

SA-CORE-2026-005 says that to be exploitable, a site must use an entity reference field type that stores a serialised property and an attacker must have permission to write to the entity through JSON:API, which it says is read-only by default.

Among the conditions SA-CORE-2025-008 lists, Drupal must be configured to handle non-public files through a custom or contributed module providing an additional file scheme. SA-CORE-2026-014 says its flaw is not directly exploitable with core alone, but that multiple serious exploit paths exist with contributed modules, that at least one known exploit path does not require authentication, and that custom code may also expose the vulnerable functionality. This page's advice: record a condition you cannot rule out as unknown, not as absent.

Custom modules and themes, and external libraries, sit outside the comparison, since advisories are only issued for projects hosted on drupal.org. This page's advice is to name a person who watches each of them, and the register gives them their own lines. For ranking and recording updates across a whole dependency tree, see the dependency security guide in this library.

Roles and permissions: what each account is allowed to do

Drupal decides what each person may do through permissions grouped into roles.

The Drupal User Guide says a user must be granted a permission to do the corresponding action, that permissions are defined by the modules that provide the actions, and that every account is automatically given the Authenticated user role.

The permissions for visitors who are not logged in sit in the Anonymous user role, and depending on the installation profile there may also be an Administrator role that is automatically assigned all permissions on the site.

From People > Roles (admin/people/roles), each role's Edit permissions link opens its Edit role page, where the available permissions depend on the modules installed, and the guide notes that some permissions may have security implications.

Some permissions carry a warning. When a module defines a permission with restrict access set and gives it no warning text of its own, Drupal core's permissions form shows "Warning: Give to trusted roles only; this permission has security implications." beside it. The advisory policy lists permissions it treats the same way, among them Administer permissions, Administer users, Administer filters, Administer modules and Administer site configuration, and says no advisory is required for an exploit that needs one of them, because a user who holds one can already take over the site or bypass various access restrictions on the site.

This page's reading: a role holding any of those permissions sits in the same trust tier as the Administrator role, so the matrix lists them role by role.

drupal.org's checklist for site builders asks you to check that roles have no more permissions than they require, not only when the site is first installed, and to look in particular at what the "authenticated user" and "anonymous user" roles hold under People > Permissions.

It also lists preventing visitors from creating their own accounts, so that only site administrators can create them, while noting that a community site needing contributions from its visitors will have to let them create low-privilege accounts.

User 1

The account created during installation is a special case. The User Guide says someone logged in as user 1 can do all actions on the site, whatever roles the account is assigned, including installing and uninstalling modules and running the update script, and that the account cannot be deleted from the administrative interface. drupal.org's page on securing that account suggests separate administrator accounts in a role holding only the permissions admin work needs, and not using an obvious name such as admin or administrator.

From Drupal 10.3.0, it says, the account's special privileges can be turned off by setting security.enable_super_user to false in the site's services.yml file, after which the Administrator role should also be removed from user 1. Editing services.yml changes the site, so the matrix only records how the account is set up.

Granted is not the same as checked

SA-CONTRIB-2026-331, dated 11 November 2026 for the Download Count module, says the module provides permissions that are never actually checked, and that a user with only the View download counts permission could export the download log and delete all download records.

A permission matrix records what each role has been granted. Whether every module checks the permissions it defines is a question for code review and testing, and this library's broken access control guide explains how such testing is done.

Text formats and input filters

Text formats decide which HTML from users reaches the page.

The User Guide says the full original text is stored in the database and passed through the filters of its text format before it is output, and that each text format has an associated permission, so that permissive formats can be kept to trusted users. The Filter module's documentation places the settings at Configuration > Content authoring > "Text formats and editors" (/admin/config/content/formats), and says that by default Drupal 8 and later ships with Basic HTML, Restricted HTML, Full HTML and Plain text.

It describes Full HTML as intended for trusted users only (administrators), because it does not restrict the allowed HTML tags at all, which can represent a severe security risk.

Restricted HTML is intended for anonymous users and Basic HTML for authenticated users, and a site installed with the minimal profile has no predefined text formats, which leaves the developer to create safe-to-use ones.

A drupal.org page on configuring text formats for security, whose navigation steps name the Drupal 6 and Drupal 7 menus, names the changes that can make the defaults unsafe: adding tags such as SCRIPT, IFRAME, OBJECT, EMBED, FORM or STYLE to filters used by roles you do not trust, moving the HTML filter away from the end of the filter order for untrusted users, and allowing advanced tags or "Full HTML" for anyone other than registered users you trust.

Administer filters is one of the permissions whose holders, the advisory policy says, can already take over the site or bypass various access restrictions on it. The cross-site scripting guide in this library explains what script in stored content can do.

For the matrix, record for each role the formats it may use and every role other than Administrator that may use Full HTML. For each format a role you do not fully trust can use, record whether "Limit allowed HTML tags and correct faulty HTML" is on, its allowed tags and the filter processing order.

REST and JSON:API: what the web services expose

Drupal core includes the JSON:API and RESTful Web Services modules, which put site data behind an HTTP API.

JSON:API's security documentation says it respects Entity Access, Field Access, validation constraints when modifying data and the internal flag, and that it does not bypass any existing security measures or add a layer of its own. It also says JSON:API has a bigger API surface out of the box than other HTTP API modules, because all non-internal entity types are made available by default, while still respecting Entity Access, and it recommends auditing Entity Access and Field Access on Drupal sites, especially if JSON:API's writing capabilities are enabled.

Whether JSON:API accepts writes is the first setting to read. The same page says its read-only mode, set at /admin/config/services/jsonapi, is turned on by default in Drupal core's JSON:API and in version 2.4 and newer of the contributed module, and that it mitigates risks from hypothetical, as-yet-unknown bugs in pre-existing validation constraints and write logic.

Two advisories in the log turn on whether writes are allowed. SA-CORE-2026-005 says JSON:API is read-only by default, so sites are only affected if they have enabled write access, and SA-CONTRIB-2026-323, for the Commerce License module, says it is mitigated by the fact that JSON:API or REST must be configured to allow writes to order items, which is not the default.

The RESTful Web Services module exposes data as REST resources. Its overview, written in Drupal 8 terms, says that out of the box it allows interaction with any content entity, such as nodes, users and comments, with config entities from Drupal 8.2.0, and with watchdog database log entries, and that it supports GET, POST, PATCH and DELETE.

Its getting-started page says HEAD, GET, OPTIONS and TRACE are the safe, read-only methods, that unsafe methods need an X-CSRF-Token request header retrieved from /session/token, and that a resource's authentication mechanisms, such as cookie, OAuth or HTTP Basic Authentication, can be customised.

SA-CORE-2026-009 brings uploads into the same picture: it says the validation rules for image uploads through the JSON:API and REST modules check the file extension but not the file MIME type.

For the matrix, record whether each module is installed, the JSON:API read-only setting and base path, each REST resource the site exposes with its methods and authentication, and which roles can create or change which entity types through either API.

Public and private files

Drupal can store uploads in a public directory or in a private file storage area, and they behave differently.

The File module documentation says files in the public directory can be accessed directly through the web server, so anyone who knows a file's URL can download it, and that a file field's upload destination by default offers only public files, available right from the server without Drupal checking any access.

Files in the private directory are not accessible directly through the web server; Drupal serves them through paths such as /system/files/name-of-the-file.pdf, which allows access restrictions to be added.

A private file field does not restrict downloads by itself. The same page says configuring a file field to use the private file system does not mean Drupal will prevent anyone from viewing its files: Drupal blocks a download through that path only if there is a specific reason to do so, such as the content the file is attached to being unpublished, and finer control needs an additional access control module.

It also says the private path cannot be set through the interface, only through $settings['file_private_path'] in settings.php, and that the private directory must exist outside the web root directory and be an absolute path.

Drupal core's default.settings.php says that directory must be absolute, outside the Drupal installation directory and not accessible over the web. The File module page also describes what it calls the simple way: a private sub-directory under the public files directory, for which Drupal creates a .htaccess file with Deny from all that stops Apache serving files from it. It notes that non-Apache web servers may need additional configuration to secure private file directories.

Caches and configuration exports belong on the same list. SA-CORE-2025-008 says files may in some cases be served with Cache-Control: public when they should be uncacheable, which can lead to some users getting cached versions of files they should not be able to access; for example, files may be cached by Varnish or a CDN.

The advisory says it is mitigated by conditions that include Drupal being configured to handle non-public files through a custom or contributed module providing an additional file scheme. default.settings.php says the configuration sync directory's default location is inside a randomly-named directory in the public files path, and its commented example sets it to a directory outside the web root.

Who can write to the code

drupal.org's guide to file permissions says the web server should not have permission to edit or write the files it executes and, if the site uses features that need the files directory, should be able to write only in that directory. It calls this defence in depth that limits what an attacker who has compromised an administrator account, or gained the ability to execute arbitrary code, can do next, and says that if your site can modify the files that form its code, you make it much easier for someone to take over your server.

Reading the permissions takes only the listing ls -al prints.

The guide notes that site administrators on shared hosting commonly lack the root access its methods assume, and points them to the provider's documentation or professional assistance. Validating and serving uploads are dealt with in this library's file upload security guide.

Update access and trusted host settings in settings.php

settings.php is where the update script's access check is set and where the trusted host patterns go.

For update.php, Drupal core's default.settings.php says that anyone running it who is not logged in with an account holding the "Administer software updates" permission, or the site maintenance account, will need to change the access check, that changing update_free_access from FALSE to TRUE disables it, and that it should be changed back after the upgrade.

The User Guide's procedure for updating core sets it to TRUE for the update and back to FALSE afterwards, and says it is FALSE by default due to security reasons. drupal.org's site builder checklist also says not to enable the Testing module, and to make sure Composer-based development tools are not installed, using composer install --no-dev.

For host names, the trusted host settings page says Drupal 8 and later can use Symfony's trusted host mechanism to prevent HTTP Host header spoofing, through $settings['trusted_host_patterns'] in settings.php: an array of regular expressions, where ^ matches the start, $ matches the end, and a dot must be escaped with a backslash to match a dot.

A request whose Host header matches none of the patterns gets HTTP 400 with the message "The provided host name is not valid for this server." The page's scenarios include password reset emails whose one-time login links point at another domain aimed at the site, and cache entries holding the wrong domain. In default.settings.php the trusted_host_patterns line is commented out.

SA-CORE-2026-007 concerns the same setting: it says core's rebuild.php front controller does not correctly check the Host header against the list of trusted host patterns, which could result in cache poisoning or a redirect to an attacker-controlled domain. The User Guide's status report page points anyone with an error about trusted host settings in their status report to the trusted host documentation.

For the matrix, copy each pattern exactly, mark any that is not anchored with ^ and $, or that leaves a dot unescaped where it is meant to match a dot, and compare the list with every host name the site serves.

The Host header injection guide in this library covers how these attacks work, and the security misconfiguration guide deals with settings that differ from one environment to the next.

Drupal security best practices drawn from drupal.org

What follows is this guide's own condensed advice from the drupal.org pages above.

The person running the site decides on each point, and the register and matrix record where things stand.

  • Keep core on a minor branch that the core release schedule lists in the security release window, and plan the move off a major version before its end-of-life date.
  • Send update notifications from Reports > Available updates > Settings to a mailbox someone reads, and subscribe that person to the drupal.org security newsletter.
  • Prefer contributed projects that show the security advisory coverage note, on stable releases, and name an owner for every custom module, custom theme and external library.
  • Keep the Anonymous user and Authenticated user roles to the permissions you intend, and give permissions that carry the trusted roles warning only to roles you would trust with the whole site.
  • Give each administrator their own account, avoid admin or administrator as the user 1 name, and consider the super user setting available from Drupal 10.3.0.
  • Keep Full HTML for trusted administrators, and keep the HTML filter at the end of the filter order in every format untrusted roles use.
  • Leave JSON:API in read-only mode unless something has to write, and expose only the REST resources and methods the site uses.
  • Put the private file path outside the web root, and add an access rule for private files that need one.
  • Keep update_free_access FALSE in production, list every host name the site serves in trusted_host_patterns, and keep the web server from writing to code files.
  • Leave public account creation off unless the site needs it, and keep the Testing module and Composer development tools off production.

Using the register as a Drupal security checklist

Make one copy for each site, and a separate copy for staging if staging can be reached from the internet.

Fill in Part A first: the core version and branch decide which entries in the advisory log can apply.

  • Every line in Parts A, B and D reads a screen, a drupal.org page, a report, a file or a command's printed output, or asks your host or developer. None asks you to change a permission, install or uninstall a module, edit settings.php or services.yml, run update.php or rebuild.php, clear a cache, or send test requests to any site.
  • Read each role from its Edit role page. Do not sign in as other users or create accounts to fill in the matrix.
  • From settings.php, copy only the settings the matrix names: update_free_access, trusted_host_patterns, file_private_path and config_sync_directory. For the database connection and hash_salt, write only whether a value is set and where it comes from. Never copy a password, salt, key or token into the register.
  • Copy versions from each advisory's "Affected versions" field, fixed releases from its solution, and the A code from its "Security risk" line.
  • Where you cannot answer, write "unknown", and keep each unknown on the findings list until someone answers it.
  • Date every line, and fill the register in again after a core or module update, a new module, a change to a role or a change to settings.php.

What the register and matrix cannot show

The register compares version numbers with the advisories you read.

It shows whether an installed release falls inside a published range, and whether the advisory's condition exists on your site as far as settings and screens can tell. Anything published after the day you read the list is missing from it.

For external libraries it records the version, where their own notices are published and who watches them, with no drupal.org advisory to compare against, and custom code kept off drupal.org has no drupal.org advisory either.

The matrix records what each role has been granted and how the site is configured. It does not show whether a module checks the permissions it defines, as the Download Count advisory illustrates, whether a custom route skips its own access check, whether a REST or JSON:API request that should be refused is refused, or whether a private file can be reached some other way. Those questions need someone working through the running site with test accounts, or reading its code.

Both are snapshots. A line dated before the most recent deployment may describe a site that has since changed, so check it again before relying on it.

Where a Clever Ops assessment fits

This page is for information only: it describes no service built around Drupal, and nothing in it tests Drupal core or a contributed module.

The register and matrix are for the people who run a Drupal site, using access they already have.

Clever Ops offers web application penetration testing for custom-built web applications and their APIs. Where your business runs one of those alongside its Drupal site, such as a member portal or a booking system, active testing of it is scoped under that service. That scope asks for a pair of test accounts in every role, each with a few sample records, so one person's access to a peer's records can be tried in each direction.

No request is sent until each target's owner has signed a written authorisation and your hosting company's rules on testing have been read.

When Clever Ops built or hosts the application under test, the work goes under the name security review, not independent penetration test, and its report sets out which business built it and which one hosts it. Clever Ops does not take on malware cleanup, emergency incident response or monitoring around the clock.

If you suspect the site is already compromised, contact an incident response specialist and your host before anything else, and read the hacked website guide in this library for the first hour.

Frequently asked questions

This guide does not rate Drupal. drupal.org's "Is Drupal secure?" page says issues such as injection, cross-site scripting and cross-site request forgeries have standard solutions in the Drupal API, and that the absolute number of security advisories is a number without meaning that should not be used for comparison. The Drupal Security Team's advisory policy covers Drupal core and the contributed projects that have opted in. It says no advisory is issued for external libraries or sandbox projects, and that none is required for a flaw whose exploit needs a permission such as Administer permissions. This page's reading: whether a given site is exposed depends on its versions, its custom code and the permissions it grants, among other things, and those are what the register records.

The Drupal core release schedule, read on 14 November 2026, gave 9 December 2026 as the end-of-life date for Drupal 10 and said Drupal 10.6.x is its last minor version. It says no new releases of a major version are made after its end-of-life date, and it listed the week of 7 December 2026 as the end of security support for the 10.6.x and 11.3.x branches. Its end-of-life table gave early December 2028 for Drupal 11. Check the schedule itself on the day you plan an upgrade.

Compare the installed version from the Status report, the Available updates report or composer audit with the advisory's "Affected versions" field, then read its description for any condition. SA-CORE-2026-004, for example, lists Drupal core from 8.9.0 to below 10.4.10 among its affected ranges, and says its SQL injection only affects sites using PostgreSQL. Copy the A code from the "Security risk" line as well: Drupal's risk level definitions say A:None means all or anonymous users. If the version is in range and the condition exists or is unknown, the advisory's solution names the release for your branch if that branch is supported, and says which branches are end-of-life and get none.

No, according to its security documentation: JSON:API's read-only mode is turned on by default in Drupal core's JSON:API and in version 2.4 and newer of the contributed module, and it can be changed at /admin/config/services/jsonapi. SA-CORE-2026-005 says sites are only affected if they have enabled write access, either through administrator configuration or the installation of a contributed or custom module that enables it. Because JSON:API respects Entity Access and Field Access, the matrix records which roles can create or change which entity types as well as the read-only setting.

Not by itself. The File module documentation says private files are served through a Drupal path such as /system/files/name-of-the-file.pdf rather than directly by the web server, but that Drupal only blocks a download if there is a specific reason to do so, such as the content the file is attached to being unpublished, and that finer control needs an additional access control module. The private path can only be set in settings.php, and Drupal core's default.settings.php says that directory must be absolute, outside the Drupal installation directory and not accessible over the web.

The advisory policy names the cases. Advisories are only issued for projects hosted on drupal.org, so external libraries and plugins get none, and the team does not create them for sandbox projects or projects hosted in external repositories. For contributed projects they cover only stable releases in supported major version branches, not development releases, alphas, betas or release candidates. And no advisory is required for an exploit that needs one of a listed set of permissions, such as Administer permissions or Administer site configuration, or any permission defined with restrict access, because the policy says a user with one can already take over the site or bypass various access restrictions.

Scope the right test for your application

Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.