Search for packages
| purl | pkg:npm/directus@9.0.0-rc.60 |
| Vulnerability | Summary | Fixed by |
|---|---|---|
|
VCID-223k-jar9-ckg1
Aliases: CVE-2026-35441 GHSA-ph52-67fq-75wj |
Directus: GraphQL Alias Amplification Denial of Service Due to Missing Query Cost/Complexity Limits ### Summary Directus' GraphQL endpoints (`/graphql` and `/graphql/system`) did not deduplicate resolver invocations within a single request. An authenticated user could exploit GraphQL aliasing to repeat an expensive relational query many times in a single request, forcing the server to execute a large number of independent complex database queries concurrently, multiplying database load linearly with the number of aliases. The existing token limit on GraphQL queries still permitted enough aliases for significant resource exhaustion, while the relational depth limit applied per alias without reducing the total number executed. Rate limiting is disabled by default, meaning no built-in throttle prevented this from causing CPU, memory, and I/O exhaustion that could degrade or crash the service. Any authenticated user, including those with minimal read-only permissions, could trigger this condition. ### Fix A request-scoped resolver deduplication mechanism was introduced and applied broadly across all GraphQL read resolvers, both system and items endpoints. When multiple aliases in a single request invoke the same resolver with identical arguments, only the first call executes; all subsequent aliases share its result. This eliminates the amplification factor regardless of how many aliases a query contains. ### Impact - **Service degradation or outage:** Concurrent complex database queries exhaust the connection pool and server resources, affecting all users - **Low privilege required:** Any authenticated user, including those with read-only access to a single collection, can trigger this condition - **Linear scaling:** Impact scales with the number of aliases and depth of relational queries - **Compounded by concurrency:** Multiple simultaneous requests multiply the effect further |
Affected by 0 other vulnerabilities. |
|
VCID-22vf-zyed-nyf8
Aliases: GHSA-q83v-hq3j-4pq3 |
Duplicate Advisory: Improper access control in Directus ## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-3fff-gqw3-vj86. This link is maintained to preserve external references. ## Original Description Directus v10.13.0 allows an authenticated external attacker to modify presets created by the same user to assign them to another user. This is possible because the application only validates the user parameter in the 'POST /presets'Â request but not in the PATCH request. When chained with CVE-2024-6533, it could result in account takeover. |
Affected by 33 other vulnerabilities. |
|
VCID-2bhb-q64y-mqhq
Aliases: CVE-2025-53887 GHSA-rmjh-cf9q-pv7q |
Directus' exact version number is exposed by the OpenAPI Spec The exact Directus version number is incorrectly being used as OpenAPI Spec version this means that it is being exposed by the `/server/specs/oas` endpoint without authentication. |
Affected by 18 other vulnerabilities. |
|
VCID-3trx-stq1-fkbf
Aliases: CVE-2024-28239 GHSA-fr3w-2p22-6w7p |
URL Redirection to Untrusted Site in OAuth2/OpenID in directus ### Summary The authentication API has a `redirect` parameter that can be exploited as an open redirect vulnerability as the user tries to log in via the API URL https://docs.directus.io/reference/authentication.html#login-using-sso-providers /auth/login/google?redirect for example. ### Details There's a redirect that is done after successful login via the Auth API GET request to `directus/auth/login/google?redirect=http://malicious-fishing-site.com`, which I think is here: https://github.com/directus/directus/blob/main/api/src/auth/drivers/oauth2.ts#L394. While credentials don't seem to be passed to the attacker site, the user can be phished into clicking a legitimate directus site and be taken to a malicious site made to look like a an error message "Your password needs to be updated" to phish out the current password. ### PoC Turn on any auth provider in Directus instance. Form a link to `directus-instance/auth/login/:provider_id?redirect=http://malicious-fishing-site.com`, login and get taken to malicious-site. Tested on the `ory` OAuth2 integration. ### Impact Users who login via OAuth2 into Directus. |
Affected by 39 other vulnerabilities. |
|
VCID-4822-z5gh-zqbw
Aliases: GHSA-9qrm-48qf-r2rw |
Directus has a DOM-Based cross-site scripting (XSS) via layout_options Directus allows an authenticated attacker to save cross site scripting code to the database. This is possible because the application injects an attacker-controlled parameter that will be stored in the server and used by the client into an unsanitized DOM element. When chained with [CVE-2024-6534](https://github.com/directus/directus/security/advisories/GHSA-3fff-gqw3-vj86), it could result in account takeover. |
Affected by 27 other vulnerabilities. |
|
VCID-4jcf-fjd5-pydt
Aliases: CVE-2026-39942 GHSA-393c-p46r-7c95 |
Directus: Path Traversal and Broken Access Control in File Management API ## Summary A broken access control vulnerability was identified in the Directus file management API that allows authenticated users to overwrite files belonging to other users by manipulating the `filename_disk` parameter. ## Details The `PATCH /files/{id}` endpoint accepts a user-controlled `filename_disk` parameter. By setting this value to match the storage path of another user's file, an attacker can overwrite that file's content while manipulating metadata fields such as `uploaded_by` to obscure the tampering. ## Impact - **Unauthorized File Overwrite**: Attackers can replace legitimate files with malicious content, creating significant risk of malware propagation and data corruption. - **Remote Code Execution**: If the storage backend is shared with the extensions location, attackers can deploy malicious extensions that execute arbitrary code when loaded. - **Data Integrity Compromise**: Files can be tampered with or replaced without visible indication in the application interface. ## Mitigation The `filename_disk` parameter should be treated as a server-controlled value. Uniqueness of storage paths must be enforced server-side, and `filename_disk` should be excluded from the fields users are permitted to update directly. |
Affected by 0 other vulnerabilities. |
|
VCID-8wt9-cu32-qugd
Aliases: CVE-2022-26969 GHSA-g27j-74fp-xfpr GMS-2022-677 |
Duplicate This advisory duplicates another. |
Affected by 41 other vulnerabilities. |
|
VCID-8zhr-k6sm-7yf6
Aliases: CVE-2026-35409 GHSA-wv3h-5fx7-966h |
Directus: SSRF Protection Bypass via IPv4-Mapped IPv6 Addresses in File Import ### Summary A Server-Side Request Forgery (SSRF) protection bypass has been identified and fixed in Directus. The IP address validation mechanism used to block requests to local and private networks could be circumvented using IPv4-Mapped IPv6 address notation. ### Details Directus implements an IP deny-list to prevent server-side requests to internal/private network ranges. The validation logic failed to normalize IPv4-Mapped IPv6 addresses (e.g., the IPv6 representation of `127.0.0.1`) before checking them against the deny-list. Because the deny-list check did not recognize these mapped addresses as equivalent to their IPv4 counterparts, an attacker could bypass the restriction while the underlying HTTP client and operating system still resolved and connected to the intended private target. This has been fixed by adding a normalization step that converts IPv4-Mapped IPv6 addresses to their canonical IPv4 form prior to validation. ### Impact An authenticated user (or an unauthenticated user if public file-import permissions are enabled) could exploit this bypass to perform SSRF attacks against internal services on the same host (databases, caches, internal APIs) or cloud instance metadata endpoints (e.g., AWS/GCP/Azure IMDS). |
Affected by 10 other vulnerabilities. |
|
VCID-9pfu-bhz9-13ea
Aliases: CVE-2024-45596 GHSA-cff8-x7jv-4fm8 |
Session is cached for OpenID and OAuth2 if `redirect` is not used Unauthenticated user can access credentials of last authenticated user via OpenID or OAuth2 where the authentication URL did not include `redirect` query string. For example: - Project is configured with OpenID or OAuth2 - Project is configured with cache enabled - User tries to login via SSO link, but without `redirect` query string - After successful login, credentials are cached - If an unauthenticated user tries to login via SSO link, it will return the credentials of the other last user The SSO link is something like `https://directus.example.com/auth/login/openid/callback`, where `openid` is the name of the OpenID provider configured in Directus |
Affected by 0 other vulnerabilities. Affected by 32 other vulnerabilities. |
|
VCID-9qru-zceb-8kb2
Aliases: CVE-2026-35413 GHSA-wxwm-3fxv-mrvx |
Directus: GraphQL Schema SDL Disclosure Setting ## Summary When `GRAPHQL_INTROSPECTION=false` is configured, Directus correctly blocks standard GraphQL introspection queries (`__schema`, `__type`). However, the `server_specs_graphql` resolver on the `/graphql/system` endpoint returns an equivalent SDL representation of the schema and was not subject to the same restriction. This allowed the introspection control to be bypassed, exposing schema structure (collection names, field names, types, and relationships) to unauthenticated users at the public permission level, and to authenticated users at their permitted permission level. ## Impact Administrators who set `GRAPHQL_INTROSPECTION=false` to hide schema structure from clients would have had a false sense of security, as equivalent schema information remained accessible via the SDL endpoint without authentication. ## Credit This vulnerability was discovered and reported by [bugbunny.ai](https://bugbunny.ai). |
Affected by 6 other vulnerabilities. |
|
VCID-9uhu-w6qs-63ez
Aliases: CVE-2024-6534 GHSA-3fff-gqw3-vj86 |
Directus has an insecure object reference via PATH presets Directus v10.13.0 allows an authenticated external attacker to modify presets created by the same user to assign them to another user. This is possible because the application only validates the user parameter in the `POST /presets` request but not in the PATCH request. When chained with [CVE-2024-6533](https://github.com/directus/directus/security/advisories/GHSA-9qrm-48qf-r2rw), it could result in account takeover. This vulnerability occurs because the application only validates the user parameter in the `POST /presets` request but not in the PATCH request. |
Affected by 32 other vulnerabilities. |
|
VCID-9y4r-6qtg-83cs
Aliases: CVE-2026-35410 GHSA-cf45-hxwj-4cfj |
Directus: Open Redirect via Parser Bypass in OAuth2/SAML Authentication Flow ### Summary An open redirect vulnerability exists in the login redirection logic. The `isLoginRedirectAllowed` function fails to correctly identify certain malformed URLs as external, allowing attackers to bypass redirect allow-list validation and redirect users to arbitrary external domains upon successful authentication. ### Details A parser differential exists between the server-side URL validation logic and how modern browsers interpret URL path segments containing backslashes. Specifically, certain URL patterns are incorrectly classified as safe relative paths by the server, but are normalized by browsers into external domain references. This is particularly impactful in SSO authentication flows (e.g., OAuth2 providers), where an attacker can craft a login URL that redirects the victim to an attacker-controlled site immediately after successful authentication, without any visible indication during the login process. ### Impact - **Phishing:** Users may be silently redirected to attacker-controlled sites impersonating legitimate services after authenticating. - **Credential/token theft:** The redirect can be chained to capture OAuth tokens or authorization codes. - **Trust erosion:** Users lose confidence in the application after being redirected to unexpected domains post-login. |
Affected by 6 other vulnerabilities. |
|
VCID-ap5v-6yzk-rud6
Aliases: CVE-2023-27481 GHSA-m5q3-8wgf-x8xf |
Exposure of Sensitive Information to an Unauthorized Actor Directus is a real-time API and App dashboard for managing SQL database content. In versions prior to 9.16.0 users with read access to the `password` field in `directus_users` can extract the argon2 password hashes by brute forcing the export functionality combined with a `_starts_with` filter. This allows the user to enumerate the password hashes. Accounts cannot be taken over unless the hashes can be reversed which is unlikely with current hardware. This problem has been patched by preventing any hashed/concealed field to be filtered against with the `_starts_with` or other string operator in version 9.16.0. Users are advised to upgrade. Users unable to upgrade may mitigate this issue by ensuring that no user has `read` access to the `password` field in `directus_users`. |
Affected by 41 other vulnerabilities. |
|
VCID-azpj-92x3-jyet
Aliases: CVE-2024-28238 GHSA-2ccr-g2rv-h677 |
Session Token in URL in directus ### Impact When reaching the /files page, a JWT is passed via GET request. Inclusion of session tokens in URLs poses a security risk as URLs are often logged in various places (e.g., web server logs, browser history). Attackers gaining access to these logs may hijack active user sessions, leading to unauthorized access to sensitive information or actions on behalf of the user. ### Patches _Has the problem been patched? What versions should users upgrade to?_ ### Workarounds There's no workaround available. ### References _Are there any links users can visit to find out more?_ |
Affected by 39 other vulnerabilities. |
|
VCID-azsd-u8r6-kqcd
Aliases: CVE-2026-35408 GHSA-8m32-p958-jg99 |
Directus: Missing Cross-Origin Opener Policy ## Summary Directus's Single Sign-On (SSO) login pages lacked a `Cross-Origin-Opener-Policy` (COOP) HTTP response header. Without this header, a malicious cross-origin window that opens the Directus login page retains the ability to access and manipulate the `window` object of that page. An attacker can exploit this to intercept and redirect the OAuth authorization flow to an attacker-controlled OAuth client, causing the victim to unknowingly grant access to their authentication provider account (e.g. Google, Discord). ## Impact A successful attack allows the attacker to obtain an OAuth access token for the victim's third-party identity provider account. Depending on the scopes authorized, this can lead to: - Unauthorized access to the victim's linked identity provider account - Account takeover of the Directus instance if the attacker can authenticate using the stolen credentials or provider session ## Patches This issue has been addressed by adding the `Cross-Origin-Opener-Policy: same-origin` HTTP response header to SSO-related endpoints. This header instructs the browser to place the page in its own browsing context group, severing any reference the opener window may hold. ## Workarounds Users who are unable to upgrade immediately can mitigate this vulnerability by configuring their reverse proxy or web server to add the following HTTP response header to all Directus responses: `Cross-Origin-Opener-Policy: same-origin` |
Affected by 0 other vulnerabilities. |
|
VCID-bm9d-bx8y-jbgy
Aliases: CVE-2022-24814 GHSA-xmjj-3c76-5w84 |
Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting') Directus is a real-time API and App dashboard for managing SQL database content. Prior to version 9.7.0, unauthorized JavaScript (JS) can be executed by inserting an iframe into the rich text html interface that links to a file uploaded HTML file that loads another uploaded JS file in its script tag. This satisfies the regular content security policy header, which in turn allows the file to run any arbitrary JS. This issue was resolved in version 9.7.0. As a workaround, disable the live embed in the what-you-see-is-what-you-get by adding `{ "media_live_embeds": false }` to the _Options Overrides_ option of the Rich Text HTML interface. |
Affected by 41 other vulnerabilities. |
|
VCID-d7x4-xpyz-9ybv
Aliases: CVE-2025-53886 GHSA-f24x-rm6g-3w5v |
Directus tokens are not redacted in flow logs, exposing session credentials to all admin When using Directus Flows with the WebHook trigger, all incoming request details are logged including security sensitive data like access and refresh tokens in cookies. |
Affected by 18 other vulnerabilities. |
|
VCID-depg-4gcv-ekb9
Aliases: CVE-2025-24353 GHSA-pmf4-v838-29hg |
Directus allows privilege escalation using Share feature When sharing an item, user can specify an arbitrary role. It allows user to use a higher-privileged role to see fields that otherwise the user should not be able to see. |
Affected by 30 other vulnerabilities. |
|
VCID-e1s2-fxgd-3ud8
Aliases: GHSA-22rr-f3p8-5gf8 GMS-2023-2358 |
Directus affected by VM2 sandbox escape vulnerability ### Impact In vm2 for versions up to 3.9.19, Promise handler sanitization can be bypassed, allowing attackers to escape the sandbox and run arbitrary code. Within Directus this applies to the "Run Script" operation in flows being able to escape the sandbox running code in the main nodejs context. ### Patches Patched in v10.6.0 by replacing `vm2` with `isolated-vm` ### Workarounds None ### References https://github.com/patriksimek/vm2/security/advisories/GHSA-cchq-frgv-rjh5 |
Affected by 40 other vulnerabilities. |
|
VCID-e6pq-efd4-yfbd
Aliases: CVE-2025-64747 GHSA-vv2v-pw69-8crf |
Directus is Vulnerable to Stored Cross-site Scripting A stored cross-site scripting (XSS) vulnerability exists that allows users with `upload files` and `edit item` permissions to inject malicious JavaScript through the Block Editor interface. Attackers can bypass Content Security Policy (CSP) restrictions by combining file uploads with iframe srcdoc attributes, resulting in persistent XSS execution. |
Affected by 13 other vulnerabilities. |
|
VCID-ew63-hmst-d7ct
Aliases: GHSA-6q22-g298-grjh |
Directus: Unauthenticated Denial of Service via GraphQL Alias Amplification of Expensive Health Check Resolver ## Summary The GraphQL specification permits a single query to repeat the same field multiple times using aliases, with each alias resolved independently by default. Directus did not deduplicate resolver invocations within a single request, meaning each alias triggered a full, independent execution of the underlying resolver. The health check resolver ran all backend checks (database connectivity, cache, storage writes, and SMTP verification) on every invocation. Combined with unauthenticated access to the system GraphQL endpoint, this allowed an attacker to amplify resource consumption significantly from a single HTTP request, exhausting the database connection pool, storage I/O, and SMTP connections. ## Fix A request-scoped resolver deduplication mechanism was introduced and applied broadly across all GraphQL read resolvers, both system and items endpoints. When multiple aliases in a single request invoke the same resolver with identical arguments, only the first call executes; all subsequent aliases share its result. This eliminates the amplification factor regardless of how many aliases an attacker includes in a query. ## Impact - **Service degradation or outage:** Database connection pool exhaustion prevents all Directus operations for all users - **Storage I/O saturation:** Concurrent file writes can overwhelm disk I/O - **SMTP resource exhaustion:** Concurrent SMTP verification calls may overwhelm the mail server - **No authentication required:** Any network-accessible attacker can trigger this condition - **Single-request impact:** A single request is sufficient to cause significant resource consumption ## Credit This vulnerability was discovered and reported by [bugbunny.ai](https://bugbunny.ai). |
Affected by 0 other vulnerabilities. |
|
VCID-fj84-xm4j-5bfw
Aliases: CVE-2022-36031 GHSA-77qm-wvqq-fg79 |
Directus vulnerable to unhandled exception on illegal filename_disk value The Directus process can be aborted by having an authorized user update the `filename_disk` value to a folder and accessing that file through the `/assets` endpoint. The vulnerability is patched and released in v9.15.0. You can prevent this problem by making sure no (untrusted) non-admin users have permissions to update the `filename_disk` field on `directus_files`. ### For more information If you have any questions or comments about this advisory: * Open a Discussion in [directus/directus](https://github.com/directus/directus/discussions) * Email us at [security@directus.io](mailto:security@directus.io) ### Credits This vulnerability was first discovered and reported by Witold Gorecki. |
Affected by 42 other vulnerabilities. |
|
VCID-gkde-rn6p-rba5
Aliases: CVE-2024-36128 GHSA-632p-p495-25m5 |
Directus is soft-locked by providing a string value to random string util This counts as an unauthenticated denial of service attack vector so this impacts all unpatched instances reachable over the internet. |
Affected by 36 other vulnerabilities. |
|
VCID-h9sb-tucg-b3fw
Aliases: CVE-2025-64749 GHSA-cph6-524f-3hgr |
Directus Vulnerable to Information Leakage in Existing Collections An observable difference in error messaging was found in the Directus REST API. The `/items/{collection}` API returns different error messages for these two cases: 1. A user tries to access an existing collection which they are not authorized to access. 2. A user tries to access a non-existing collection. The two differing error messages leak the existence of collections to users which are not authorized to access these collections. |
Affected by 13 other vulnerabilities. |
|
VCID-hp3s-jfj1-efdy
Aliases: CVE-2026-26185 GHSA-jr94-gj3h-c8rf |
Directus Vulnerable to User Enumeration via Password Reset Timing Attack A timing-based user enumeration vulnerability exists in the password reset functionality. When an invalid reset_url parameter is provided, the response time differs by approximately 500ms between existing and non-existing users, enabling reliable user enumeration. |
Affected by 11 other vulnerabilities. |
|
VCID-j9tx-h9v5-w7am
Aliases: CVE-2025-64748 GHSA-8jpw-gpr4-8cmh |
Directus's conceal fields are searchable if read permissions enabled A vulnerability allows authenticated users to search concealed/sensitive fields when they have read permissions. While actual values remain masked (`****`), successful matches can be detected through returned records, enabling enumeration attacks on sensitive data. |
Affected by 13 other vulnerabilities. |
|
VCID-m4z2-58pn-k3cb
Aliases: CVE-2026-39943 GHSA-mvv8-v4jj-g47j |
Directus: Sensitive fields exposed in revision history ### Summary Directus stores revision records (in `directus_revisions`) whenever items are created or updated. Due to the revision snapshot code not consistently calling the `prepareDelta` sanitization pipeline, sensitive fields (including user tokens, two-factor authentication secrets, external auth identifiers, auth data, stored credentials, and AI provider API keys) could be stored in plaintext within revision records. ### Impact Any user or service account with read access to `directus_revisions` (or flow logs) could retrieve values for fields that are supposed to be concealed or encrypted at rest, including: - `token`, `tfa_secret`, `external_identifier`, `auth_data`, `credentials` - `ai_openai_api_key`, `ai_anthropic_api_key`, `ai_google_api_key`, `ai_openai_compatible_api_key` This could lead to account takeover (via stolen tokens or 2FA secrets) or unauthorized use of third-party API keys stored against users. ### Affected code paths 1. **Item create/update revisions** The data (snapshot) field written to directus_revisions was not processed through prepareDelta, so concealed/encrypted fields were stored without redaction. Relational fields were also included, which should have been excluded. 2. **Authentication service** When a user was auto-suspended after repeated failed login attempts, the revision record was created with the raw user object (including all sensitive fields) rather than the sanitized delta. |
Affected by 0 other vulnerabilities. |
|
VCID-ntrh-xsrv-hydn
Aliases: CVE-2022-23080 GHSA-5h75-pvq4-82c9 |
Server-Side Request Forgery in Directus Directus versions v9.0.0-beta.2 through 9.6.0 are vulnerable to server-side request forgery (SSRF) in the media upload functionality, which allows a low privileged user to perform internal network port scans. |
Affected by 41 other vulnerabilities. |
|
VCID-nug7-m3d7-f7gq
Aliases: CVE-2025-53889 GHSA-7cvf-pxgp-42fc |
Directus' insufficient permission checks can enable unauthenticated users to manually trigger Flows Directus Flows with a manual trigger are not validating whether the user triggering the Flow has permissions to the items provided as payload to the Flow. Depending on what the Flow is set up to do this can lead to the Flow executing potential tasks on the attacker's behalf without authenticating. |
Affected by 18 other vulnerabilities. |
|
VCID-p425-cguh-83c8
Aliases: CVE-2023-27474 GHSA-4hmq-ggrm-qfc6 |
Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting') Directus is a real-time API and App dashboard for managing SQL database content. Instances relying on an allow-listed reset URL is vulnerable to an HTML injection attack through the use of query parameters in the reset URL. An attacker could exploit this to email users urls to the servers domain but which may contain malicious code. The problem has been resolved and released under version 9.23.0. People relying on a custom password reset URL should upgrade to 9.23.0 or later, or remove the custom reset url from the configured allow list. Users are advised to upgrade. Users unable to upgrade may disable the custom reset URL allow list as a workaround. |
Affected by 1 other vulnerability. Affected by 42 other vulnerabilities. |
|
VCID-p9j6-rpp2-bqd6
Aliases: CVE-2026-22032 GHSA-3573-4c68-g8cc |
Directus has open redirect in SAML An open redirect vulnerability exists in the Directus SAML authentication callback endpoint. The `RelayState` parameter is used in redirects without proper validation against an allowlist of permitted domains. |
Affected by 12 other vulnerabilities. |
|
VCID-pdb5-hm2r-xfga
Aliases: CVE-2024-27295 GHSA-qw9g-7549-7wg5 |
Directus has MySQL accent insensitive email matching ## Password reset vulnerable to accent confusion The password reset mechanism of the Directus backend is implemented in a way where combined with (specific, need to double check if i can work around) configuration in MySQL or MariaDB. As such, it allows attackers to receive a password reset email of a victim user, specifically having it arrive at a similar email address as the victim with a one or more characters changed to use accents. This is due to the fact that by default MySQL/MariaDB are configured for accent-insenstive and case-insensitve comparisons. MySQL weak comparison: ```sql select 1 from directus_users where 'julian@cure53.de' = 'julian@cüre53.de'; ``` This is exploitable due to an error in the API using the supplied email address for sending the reset password mail instead of using the email from the database. ### Steps to reproduce: 1. If the attacker knows the email address of the victim user, i.e., `julian@cure53.de`. (possibly just the domain could be enough for an educated guess) 2. A off-by-one accented domain `cüre53.de` can be registered to be able to receive emails. 3. With this email the attacker can request a password reset for `julian@cüre53.de`. ```http POST /auth/password/request HTTP/1.1 Host: example.com [...] {"email":"julian@cüre53.de"} ``` 4. The supplied email (julian@cüre53.de) gets checked against the database and will match the non-accented email `julian@cure53.de` and will continue to email the password reset link to the provided email address instead of the saved email address. 5. With this email the attacker can log into the target account and use it for nefarious things ### Workarounds Should be possible with collations but haven't been able to confirm this. ### References - https://www.monolune.com/articles/what-is-the-utf8mb4_0900_ai_ci-collation/ - https://dev.mysql.com/doc/refman/8.0/en/charset-unicode-sets.html |
Affected by 38 other vulnerabilities. |
|
VCID-qb7x-z5hp-qqcx
Aliases: CVE-2023-28443 GHSA-8vg2-wf3q-mwv7 |
Insertion of Sensitive Information into Log File Directus is a real-time API and App dashboard for managing SQL database content. Prior to version 9.23.3, the `directus_refresh_token` is not redacted properly from the log outputs and can be used to impersonate users without their permission. This issue is patched in version 9.23.3. |
Affected by 41 other vulnerabilities. |
|
VCID-r972-eutc-73fh
Aliases: CVE-2025-64746 GHSA-9x5g-62gj-wqf2 |
Directus has Improper Permission Handling on Deleted Fields Directus does not properly clean up field-level permissions when a field is deleted. If a new field with the same name is created later, the system automatically re-applies the old permissions, which can lead to unauthorized access. |
Affected by 13 other vulnerabilities. |
|
VCID-t16j-g2em-wqem
Aliases: CVE-2024-27296 GHSA-5mhg-wv8w-p59j |
Directus version number disclosure ### Impact Currently the exact Directus version number is being shipped in compiled JS bundles which are accessible without authentication. With this information a malicious attacker can trivially look for known vulnerabilities in Directus core or any of its shipped dependencies in that specific running version. ### Patches The problem has been resolved in versions 10.8.3 and newer ### Workarounds None |
Affected by 38 other vulnerabilities. |
|
VCID-tz3z-smv5-3ydd
Aliases: CVE-2023-26492 GHSA-j3rg-3rgm-537h |
Directus is a real-time API and App dashboard for managing SQL database content. Directus is vulnerable to Server-Side Request Forgery (SSRF) when importing a file from a remote web server (POST to `/files/import`). An attacker can bypass the security controls by performing a DNS rebinding attack and view sensitive data from internal servers or perform a local port scan. An attacker can exploit this vulnerability to access highly sensitive internal server(s) and steal sensitive information. This issue was fixed in version 9.23.0. |
Affected by 1 other vulnerability. Affected by 42 other vulnerabilities. |
|
VCID-ut99-st7g-yqh6
Aliases: CVE-2024-34708 GHSA-p8v3-m643-4xqx |
Directus allows redacted data extraction on the API through "alias" A user with permission to view any collection using redacted hashed fields can get access the raw stored version using the `alias` functionality on the API. Normally, these redacted fields will return `**********` however if we change the request to `?alias[workaround]=redacted` we can instead retrieve the plain text value for the field. |
Affected by 37 other vulnerabilities. |
|
VCID-v44m-ug4p-mqhv
Aliases: CVE-2026-35412 GHSA-qqmv-5p3g-px89 |
Directus: TUS Upload Authorization Bypass Allows Arbitrary File Overwrite ## Summary Directus' TUS resumable upload endpoint (`/files/tus`) allows any authenticated user with basic file upload permissions to overwrite arbitrary existing files by UUID. The TUS controller performs only collection-level authorization checks, verifying the user has some permission on `directus_files`, but never validates item-level access to the specific file being replaced. As a result, row-level permission rules (e.g., "users can only update their own files") are completely bypassed via the TUS path while being correctly enforced on the standard REST upload path. ## Impact - **Arbitrary file overwrite:** Any authenticated user with basic TUS upload permissions can overwrite any file in `directus_files` by UUID, regardless of row-level permission rules. - **Permanent data loss:** The victim file's original stored bytes are deleted from storage and replaced with attacker-controlled content. - **Metadata corruption:** The victim file's database record is updated with the attacker's filename, type, and size metadata. Privilege escalation potential: If admin-owned files (e.g., application assets, templates) are stored in `directus_files`, a low-privilege user could replace them with malicious content. ## Workaround Disable TUS uploads by setting `TUS_ENABLED=false` if resumable uploads are not required. ## Credit This vulnerability was discovered and reported by [bugbunny.ai](https://bugbunny.ai). |
Affected by 6 other vulnerabilities. |
|
VCID-v46e-qqux-7fdq
Aliases: CVE-2026-35411 GHSA-q75c-4gmv-mg9x |
Directus: Open Redirect in Admin 2FA Setup Page ### Summary Directus is vulnerable to an Open Redirect via the redirect query parameter on the `/admin/tfa-setup` page. When an administrator who has not yet configured Two-Factor Authentication (2FA) visits a crafted URL, they are presented with the legitimate Directus 2FA setup page. After completing the setup process, the application redirects the user to the attacker-controlled URL specified in the `redirect` parameter without any validation. This vulnerability could be used in phishing attacks targeting Directus administrators, as the initial interaction occurs on a trusted domain. ### Credits Discovered by Neo by ProjectDiscovery (https://neo.projectdiscovery.io/) |
Affected by 6 other vulnerabilities. |
|
VCID-wvhh-m37j-nff5
Aliases: CVE-2026-35442 GHSA-38hg-ww64-rrwc |
Directus: Authenticated Users Can Extract Concealed Fields via Aggregate Queries ### Summary Aggregate functions (`min`, `max`) applied to fields with the `conceal` special type incorrectly return raw database values instead of the masked placeholder. When combined with `groupBy`, any authenticated user with read access to the affected collection can extract concealed field values, including static API tokens and two-factor authentication secrets from `directus_users`. ### Details Fields marked with `conceal` are protected by payload processing logic that replaces real values with a masked placeholder on read. This protection works correctly for standard item queries, but aggregate query results are structured differently, operations are nested under their function name rather than appearing as flat field keys. The masking logic does not account for this nested structure, causing it to silently skip concealed fields in aggregate responses and return their raw values to the client. ### Impact - **Account Takeover** An authenticated attacker can harvest static API tokens for all users, including administrators, enabling immediate authentication as any account without credentials. - **2FA Bypass** TOTP seeds stored in directus_users can similarly be extracted, allowing an attacker to bypass two-factor authentication for any account. |
Affected by 0 other vulnerabilities. |
|
VCID-ydha-8cmf-hbdx
Aliases: CVE-2025-30352 GHSA-7wq3-jr35-275c |
Directus `search` query parameter allows enumeration of non permitted fields The `search` query parameter allows users with access to a collection to filter items based on fields they do not have permission to view. This allows the enumeration of unknown field contents. |
Affected by 22 other vulnerabilities. |
|
VCID-z5ka-gqzc-kued
Aliases: CVE-2024-6533 GHSA-qf6h-p3mr-vmh5 |
Duplicate This advisory duplicates another. |
Affected by 33 other vulnerabilities. |
|
VCID-z7yb-1fvm-bqes
Aliases: CVE-2024-46990 GHSA-68g8-c275-xf2m |
Directus vulnerable to SSRF Loopback IP filter bypass If you're relying on blocking access to localhost using the default `0.0.0.0` filter this can be bypassed using other registered loopback devices (like `127.0.0.2` - `127.127.127.127`) |
Affected by 0 other vulnerabilities. Affected by 31 other vulnerabilities. Affected by 32 other vulnerabilities. |
| Vulnerability | Summary | Aliases |
|---|---|---|
| This package is not known to fix vulnerabilities. | ||