### Summary
In affected versions of `astro`, the image optimization endpoint in projects deployed with on-demand rendering allows images from unauthorized third-party domains to be served.
### Details
On-demand rendered sites built with Astro include an `/_image` endpoint which returns optimized versions of images.
The `/_image` endpoint is restricted to processing local images bundled with the site and also supports remote images from domains the site developer has manually authorized (using the [`image.domains`](https://docs.astro.build/en/reference/configuration-reference/#imagedomains) or [`image.remotePatterns`](https://docs.astro.build/en/reference/configuration-reference/#imageremotepatterns) options).
However, a bug in impacted versions of `astro` allows an attacker to bypass the third-party domain restrictions by using a protocol-relative URL as the image source, e.g. `/_image?href=//example.com/image.png`.
### Proof of Concept
1. Create a new minimal Astro project (`astro@5.13.0`).
2. Configure it to use the Node adapter (`@astrojs/node@9.1.0` — newer versions are not impacted):
```js
// astro.config.mjs
import { defineConfig } from 'astro/config';
import node from '@astrojs/node';
export default defineConfig({
adapter: node({ mode: 'standalone' }),
});
```
3. Build the site by running `astro build`.
4. Run the server, e.g. with `astro preview`.
5. Append `/_image?href=//placehold.co/600x400` to the preview URL, e.g. <http://localhost:4321/_image?href=//placehold.co/600x400>
6. The site will serve the image from the unauthorized `placehold.co` origin.
### Impact
Allows a non-authorized third-party to create URLs on an impacted site’s origin that serve unauthorized image content.
In the case of SVG images, this could include the risk of cross-site scripting (XSS) if a user followed a link to a maliciously crafted SVG.
## Summary
There is an Open Redirection vulnerability in the trailing slash redirection logic when handling paths with double slashes. This allows an attacker to redirect users to arbitrary external domains by crafting URLs such as `https://mydomain.com//malicious-site.com/`. This increases the risk of phishing and other social engineering attacks.
This affects Astro >=5.2.0 sites that use on-demand rendering (SSR) with the Node or Cloudflare adapter. It does not affect static sites, or sites deployed to Netlify or Vercel.
## Background
Astro performs automatic redirection to the canonical URL, either adding or removing trailing slashes according to the value of the [`trailingSlash`](https://docs.astro.build/en/reference/configuration-reference/#trailingslash) configuration option. It follows the following rules:
- If `trailingSlash` is set to `"never"`, `https://example.com/page/` will redirect to `https://example.com/page`
- If `trailingSlash` is set to `"always"`, `https://example.com/page` will redirect to `https://example.com/page/`
It also collapses multiple trailing slashes, according to the following rules:
- If `trailingSlash` is set to `"always"` or `"ignore"` (the default), `https://example.com/page//` will redirect to `https://example.com/page/`
- If `trailingSlash` is set to `"never"`, `https://example.com/page//` will redirect to `https://example.com/page`
It does this by returning a `301` redirect to the target path. The vulnerability occurs because it uses a relative path for the redirect. To redirect from `https://example.com/page` to `https://example.com/page/`, it sending a 301 response with the header `Location: /page/`. The browser resolves this URL relative to the original page URL and redirects to `https://example.com/page/`
## Details
The vulnerability occurs if the target path starts with `//`. A request for `https://example.com//page` will send the header `Location: //page/`. The browser interprets this as a [protocol-relative URL](https://en.wikipedia.org/wiki/URL#Protocol-relative_URLs), so instead of redirecting to `https://example.com//page/`, it will attempt to redirect to `https://page/`. This is unlikely to resolve, but by crafting a URL in the form `https://example.com//target.domain/subpath`, it will send the header `Location: //target.domain/subpath/`, which the browser translates as a redirect to `https://target.domain/subpath/`. The subpath part is required because otherwise Astro will interpret `/target.domain` as a file download, which skips trailing slash handling.
This leads to an [Open Redirect](https://cwe.mitre.org/data/definitions/601.html) vulnerability.
The URL needed to trigger the vulnerability varies according to the `trailingSlash` setting.
- If `trailingSlash` is set to `"never"`, a URL in the form `https://example.com//target.domain/subpath/`
- If `trailingSlash` is set to `"always"`, a URL in the form `https://example.com//target.domain/subpath`
- For any config value, a URL in the form `https://example.com//target.domain/subpath//`
## Impact
This is classified as an Open Redirection vulnerability (CWE-601). It affects any user who clicks on a specially crafted link pointing to the affected domain. Since the domain appears legitimate, victims may be tricked into trusting the redirected page, leading to possible credential theft, malware distribution, or other phishing-related attacks.
No authentication is required to exploit this vulnerability. Any unauthenticated user can trigger the redirect by clicking a malicious link.
## Mitigation
Usrs can test if your site is affected by visiting `https://yoursite.com//docs.astro.build/en//`. If a user is redirected to the Astro docs then their site is affected and must be updated.
Upgrade to Astro 5.12.8. To mitigate at the network level, block outgoing redirect responses with a `Location` header value that starts with `//`.
### Summary
A path traversal vulnerability was discovered in WASM Traefik’s plugin installation mechanism. By supplying a maliciously crafted ZIP archive containing file paths with `../` sequences, an attacker can overwrite arbitrary files on the system outside of the intended plugin directory. This can lead to remote code execution (RCE), privilege escalation, persistence, or denial of service.
**✅ After investigation, it is confirmed that no plugins on the [Catalog](https://plugins.traefik.io/plugins) were affected. There is no known impact.**
### Details
The vulnerability resides in the WASM plugin extraction logic, specifically in the `unzipFile` function (`/plugins/client.go`). The application constructs file paths during ZIP extraction using `filepath.Join(destDir, f.Name)` without validating or sanitizing `f.Name`. If the ZIP archive contains entries with `../`, the resulting path can escape the intended directory, allowing writes to arbitrary locations on the host filesystem.
### Attack Requirements
There are several requirements needed to make this attack possible:
- The Traefik server should be deployed with [plugins enabled](https://doc.traefik.io/traefik/plugins/) with a WASM plugin (yaegi plugins are not impacted).
- The attacker should have write access to a remote plugin asset loaded by the Traefik server
- The attacker should craft a malicious version of this plugin
### Warning
As clearly stated in the [documentation](https://doc.traefik.io/traefik/plugins/), plugins are experimental in Traefik, and unsafe plugins could damage your infrastructure:
> **Experimental Features**
Plugins can change the behavior of Traefik in unforeseen ways. Exercise caution when adding new plugins to production Traefik instances.
### Impact
**This vulnerability did not affect any plugin from the catalog. There is no known impact.
Additionally, the catalog will also prevent any compromised plugin to be available across all Traefik versions.**
This vulnerability can allow an attacker to perform arbitrary file write outside the intended plugin extraction directory by crafting a malicious ZIP archive that includes `../` (directory traversal) in file paths.
An improper access control vulnerability in the secure message component of Devolutions Server allows an authenticated user to steal unauthorized entries via the secure message entry attachment feature. This affects versions 2025.2.2.0 through 2025.2.4.0 and all versions 2025.1.11.0 and earlier. The vulnerability has a high severity with a CVSS score of 7.7.
Devolutions Server versions 2025.1.11.0 and earlier through 2025.2.3.0 contain a vulnerability in the emergency authentication component that uses weak credentials. This flaw allows an unauthenticated attacker to bypass authentication by brute forcing short emergency codes within a feasible timeframe. The vulnerability has a high severity rating with a CVSS score of 7.7.
An improper access control vulnerability exists in user group management in Devolutions Server versions 2025.1.7.0 and earlier. This flaw allows a non-administrative user who has both "User Management" and "User Group Management" permissions to escalate their privileges by adding users to groups with administrative rights.
## Impact
There is a potential vulnerability in Traefik managing the requests using a `PathPrefix`, `Path` or `PathRegex` matcher.
When Traefik is configured to route the requests to a backend using a matcher based on the path, if the URL contains a URL encoded string in its path, it’s possible to target a backend, exposed using another router, by-passing the middlewares chain.
## Example
```yaml
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
name: my-service
spec:
routes:
- match: PathPrefix(‘/service’)
kind: Rule
services:
- name: service-a
port: 8080
middlewares:
- name: my-middleware-a
- match: PathPrefix(‘/service/sub-path’)
kind: Rule
services:
- name: service-a
port: 8080
```
In such a case, the request `http://mydomain.example.com/service/sub-path/%2e%2e/other-path` will reach the backend `my-service-a` without operating the middleware `my-middleware-a` unless the computed path is `http://mydomain.example.com/service/other-path` and should be computes by the first router (operating `my-middleware-a`).
## Patches
- https://github.com/traefik/traefik/releases/tag/v2.11.25
- https://github.com/traefik/traefik/releases/tag/v3.4.1
## For more information
If you have any questions or comments about this advisory, please [open an issue](https://github.com/traefik/traefik/issues).
<details>
<summary>Original Description</summary>
### Summary
Path traversal with "/../" using URL encodings ("/%2e%2e") allows for circumventing routing rules.
### Details
When having defined a route, you can path traverse using the URL encoded variant of /../ and reach endpoints that are not made publicly available. This issue has been found and fixed earlier with regular /../ and has been fixed in this CVE. This URL encoding trick works around that
https://nvd.nist.gov/vuln/detail/CVE-2025-32431
Simply implementing a check on the URL encoding won't be sufficient as path traversal can take numerous formats. See examples here:
https://book.hacktricks.wiki/en/pentesting-web/file-inclusion/index.html
### PoC
Setup a service with two endpoints: "/public" and "/private", which returns a 200 OK for both
Setup a Traefik proxy with a single route which points to the service using path /public
Regular requests to traefik /public will return 200 OK and to /private should return 404 (response by Traefik)
When making a request to /public/%2e%2e/private you should receive a 200 OK.
### Impact
Impacts all traefik implementations with path prefix routes that expose only part of the downstream api
### Suggestion
Provide configuration property which disables all path traversals. Steps:
1. Decode URL
2. Evaluate and construct relative path (do traversal before route evaluation)
3. Compare relative/evaluated path to configured routes (PathPrefix/pathRegexp)
</details>
Multiple vulnerabilities have been identified in the Danfoss AK-SM 8xxA Series (Update A) product line. CISA recommends users implement defensive measures to reduce the risk of exploitation. Specific affected versions and detailed technical impact are not provided in the available data.
A vulnerability in Vercel's Next.js framework allows information disclosure. Next.js is a React-based web application framework. The issue affects versions before 15.1.6 and is fixed in version 15.1.6.
A vulnerability identified as CVE-2025-22235 affects VMware Tanzu Spring Boot, allowing the bypass of security measures. Spring Boot is a Java application development framework based on the Spring Framework. The issue impacts versions prior to 10.0.2, with version 10.0.2 containing the fix.
## Impact
There is a potential vulnerability in Traefik managing the requests using a `PathPrefix`, `Path` or `PathRegex` matcher.
When Traefik is configured to route the requests to a backend using a matcher based on the path, if the URL contains a `/../` in its path, it’s possible to target a backend, exposed using another router, by-passing the middlewares chain.
## Example
```yaml
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
name: my-service
spec:
routes:
- match: PathPrefix(‘/service’)
kind: Rule
services:
- name: service-a
port: 8080
middlewares:
- name: my-middleware-a
- match: PathPrefix(‘/service/sub-path’)
kind: Rule
services:
- name: service-a
port: 8080
```
In such a case, the request `http://mydomain.example.com/service/sub-path/../other-path` will reach the backend `my-service-a` without operating the middleware `my-middleware-a` unless the computed path is `http://mydomain.example.com/service/other-path` and should be computes by the first router (operating `my-middleware-a`).
## Patches
- https://github.com/traefik/traefik/releases/tag/v2.11.24
- https://github.com/traefik/traefik/releases/tag/v3.3.6
- https://github.com/traefik/traefik/releases/tag/v3.4.0-rc2
## Workaround
Add a `PathRegexp` rule to the matcher to prevent matching a route with a `/../` in the path.
Example:
```yaml
match: PathPrefix(`/service`) && !PathRegexp(`(?:(/\.\./)+.*)`)
```
## For more information
If you have any questions or comments about this advisory, please [open an issue](https://github.com/traefik/traefik/issues).
A critical heap-based buffer overflow vulnerability exists in WebAssembly wabt version 1.0.36 and earlier, specifically in the function BinaryReaderInterp::GetReturnCallDropKeepCount. The vulnerability can be triggered remotely but requires high attack complexity and user interaction. Exploit code has been publicly disclosed, though exploitation is considered difficult. The vulnerability impacts confidentiality and availability but not integrity.
Open WebUI version prior to 0.3.16 is vulnerable to Cross-Site Request Forgery (CSRF) due to sensitive actions being performed via GET requests. This allows attackers to trick users into unintentionally executing sensitive operations such as resetting or deleting data by visiting malicious sites. The vulnerability affects multiple endpoints related to resetting application state and data, impacting the application's integrity and availability.
Open-webui version prior to 0.3.16 contains an improper access control vulnerability that allows attackers to view and delete any files without administrator verification. Attackers can enumerate file IDs via the GET /api/v1/files/ endpoint and then access or delete files using the respective GET and DELETE endpoints. This vulnerability is fixed in version 0.3.16.
Multiple security vulnerabilities have been identified in VMware Tanzu Spring Security and related components, including a failure to enforce maximum password length in BCryptPasswordEncoder. These issues affect Spring Security and related Red Hat products such as Apache Camel for Spring Boot and OpenShift Developer Tools. Red Hat has released security updates addressing these vulnerabilities. The vulnerabilities include potential denial of service via stack exhaustion, bypass of header filters, and improper SSL packet validation. No active exploitation in the wild has been reported.