Datasets through 5.00, fixed in commit ad2d853, contains a symlink-following vulnerability in Extractor.extract() that allows local attackers to write arbitrary files by pre-planting symlinks at predictable output paths. Attackers can redirect archive extraction to arbitrary filesystem locations in shared-cache environments, enabling overwrite of sensitive files and potential privilege escalation or code execution.
This update for unbound fixes the following issues:
Update to version 1.25.2.
Security issues fixed:
- CVE-2026-14586: DoS via assertion in `libngtcp2` for DNS-over-QUIC environments with high concurrency (bsc#1271879).
- CVE-2026-32665: Remote DNS-over-QUIC denial of service due to `quic-size` budget bypass (bsc#1271873).
- CVE-2026-40691: DoS due to heap overflow via single bad DNSCrypt query over TCP (bsc#1271875).
- CVE-2026-41637: Degradation of resolution service due to improperly accounted client-terminated DNS-over-QUIC queries
(bsc#1271891).
- CVE-2026-42955: Ghost domain window can be extended by up to one cached TTL configured value for A/AAAA glue records
(bsc#1271892).
- CVE-2026-44621: Libunbound applications configured with `unwanted-reply-threshold` could eventually be abruptly
terminated (bsc#1271876).
- CVE-2026-44687: Off-by-one error in `harden-below-nxdomain` logic can shadow a stub/forward zone by a legitimate
parent's `NXDOMAIN` (bsc#1271893).
- CVE-2026-44690: Cross-zone wildcard cache poisoning via `RRSIG.labels` manipulation (bsc#1271877).
- CVE-2026-46582: Replay of a wildcard `rrset` as another piece of data triggers poisoning in the server expired reply
path (bsc#1271894).
- CVE-2026-50045: `max-global-quota` bypass via single client queries for a deeply nested name under a DNSSEC-signed
parent (bsc#1271878).
- CVE-2026-50046: Possible heap use-after-free in an error path when a DoT forwarded query is jostled out (bsc#1271882).
- CVE-2026-50243: `response-ip`/`rpz` can rewrite BOGUS answers instead of returning SERVFAIL (bsc#1271880).
- CVE-2026-50248: BOGUS configured primary hostname accepted for XFR in auth/rpz zones (bsc#1271881).
- CVE-2026-50251: Attacker supplied `0.0.0.0`/`::` glue triggers defensive full-cache flush (bsc#1271883).
- CVE-2026-50252: Possible cache poisoning attack by mapping source port population per thread (bsc#1271884).
- CVE-2026-54478: DNS Cookie bypass when proxy-protocol with with `answer-cookie:yes` is used (bsc#1271895).
- CVE-2026-55708: Privacy/configuration issue when adding local data in views through `unbound-control` (bsc#1271896).
- CVE-2026-55717: `serve-expired-client-timeout` and `response-ip` CNAME redirect could lead to a crash (bsc#1271886).
- CVE-2026-55973: DoS due to stack overflow triggered crash when `dns-error-reporting: yes` is set (bsc#1271874).
- CVE-2026-55990: Crash via crafted client UDP query due to DNSCrypt faulty configuration (bsc#1271887).
- CVE-2026-55991: Remote DNS-over-QUIC (DoQ) flow-control reacheable assertion failure in `libngtcp2` (bsc#1271888).
- CVE-2026-56416: Possible heap buffer overflow when validator canonicalizes RDATA that contains domain name
(bsc#1271889).
- CVE-2026-56444: Degradation of resolution service when `discard-timeout` and `serve-expired-client-timeout` are
combined in unusual configuration (bsc#1271890).
Other updates and bugfixes:
- Version 1.25.2:
+ Features:
* TTL behavior changes: cached records reaching TTL 0 are expired;
TTL 0 upstream answers are no longer cached by cachedb;
serve-expired-reply-ttl is now capped by the original TTL value;
TTL decoding updated to adhere to RFC 8767 section 4
* Add new statistics: num.queries.replyaddr_limit and
requestlist.current.replies
* Add 'log-thread-id' configuration option to log the system-wide
Linux thread ID for easier debugging
* Add ECC-GOST12 support per RFC 9558 (available as
contrib/gost12.patch)
* Allow synthesized DNAME TTL=0 to be served from cache within a
1-second grace period, reducing recursion for TTL=0 DNAMEs
(RFC 2308)
* Fix DoT/DoH/DoQ to reload certificates on config reload without
requiring a full restart; fast_reload now supports changes to
tls-service-key, tls-service-pem and tls-cert-bundle
* Allow ip@port notation in control-interface configuration
* Add iter-scrub-rrsig option (default: 8) to limit the number of
RRSIGs processed by the scrubber
* Add 'tls-protocols' configuration option to select which TLS
protocol versions are used; TLSv1.2 is re-enabled by default
* Add pthread_setname_np support for named threads
+ Bug Fixes:
* Fix handle leak in pythonmod on pythonmod_init
* Fix crash when mesh_detect_cycle_found() is called with no mesh
state
* Fix modstack_call_init to use the original string when it has
changed
* Fix fr_atomic_copy_cfg
* Fix auth-zone empty label for $ORIGIN when downloading via HTTP
* Fix respip and dns64 to be usable simultaneously; RPZ now works
with DNS64
* Fix HTTPS and QUIC not being enabled when port is listed in
interface-automatic-ports
* Allow wait-limit-cookie: 0 to disable cookie-validated wait limits
* Fix FIPS mode in OpenSSL causing unit test failure
* Fix discard-timeout to only drop UDP, not stream connections
* Reply with SERVFAIL when the wait-limit is exceeded
* A
Unblu Spark contains an open redirect vulnerability that can be escalated to a DOM-based cross-site scripting (XSS) attack.
When Unblu Spark is deployed with com.unblu.identifier.siteEmbeddedSetup=true, it runs in the same origin as the host application. Any JavaScript injected through this vulnerability therefore executes with full access to the host application's cookies, DOM, and same-origin APIs — an attacker can reach all resources of the host application, not just Unblu's. This expanded blast radius is the reason on-premises deployments using this configuration are rated CRITICAL.
LMDeploy through 0.14.0, fixed in commit 03c3130, contains a server-side request forgery (SSRF) vulnerability in the _load_http_url function within the connection.py media handler, where the private-IP guard validates only the original URL without re-validating hosts after HTTP redirects. An unauthenticated attacker can submit a crafted image_url to the chat completions endpoint pointing to an attacker-controlled host that returns a redirect to a private IP or cloud-metadata endpoint, causing the server to follow the redirect and expose internal service content through the model pipeline.
Data::RingBuffer::Shared versions before 0.04 for Perl create a memory-mapped backing file with world-readable permissions and open it without using secure flags O_EXCL or O_NOFOLLOW. This allows local users to read inter-process communication payloads stored in the shared segment and enables local attackers to exploit race conditions or symlink attacks to redirect file access. The vulnerability arises from incorrect permission assignment and insecure file opening practices in a shared directory.
Data::PubSub::Shared versions before 0.07 for Perl create a memory-mapped file with overly permissive permissions (world-readable) and open it without safeguards against symlink attacks or race conditions. This allows local users to read inter-process communication payloads and potentially exploit pre-created files or symlinks to redirect file operations.
A vulnerability was found in trinodb trino 481. Affected is an unknown function of the file core/trino-main/src/main/java/io/trino/server/ExternalUriInfo.java of the component OAuth2/OIDC. Performing a manipulation of the argument redirect_uri results in open redirect. It is possible to initiate the attack remotely. The project was informed of the problem early through an issue report but has not responded yet.
AVideo versions from commit 0dbadbca through latest master contain a server-side request forgery vulnerability in the encoder download-by-URL flow due to an unpinned retry fallback that bypasses DNS pinning validation. An authenticated attacker can supply a downloadURL that redirects to an internal address, causing the unpinned retry to follow the redirect and reach internal targets for blind SSRF attacks.
cal.diy through 6.2.0 contains an open redirect vulnerability in the conferencing OAuth callback endpoint that allows attackers to redirect users to arbitrary URLs by crafting malicious state parameters. Attackers can exploit the unsigned state parameter and onErrorReturnTo field to silently redirect visitors from the trusted domain to attacker-controlled URLs for phishing attacks.
An open redirect vulnerability (CWE-601) exists in the Hikashop extension for Joomla versions 1.0.0 through 6.5.1. This vulnerability allows an attacker to redirect users to untrusted external sites via crafted URLs. The issue is classified as medium severity with a CVSS score of 6.1. No official patch or remediation guidance is currently provided by the vendor.
dataCycle is a data management system for centrally storing, managing, searching, finding, and distributing data. In dataCycle-CORE, the module handling core processing and framework rules, before and including version 25.07.3, a low-privileged authenticated API user can supply `forwardToUrl` and `redirectUrl` values when triggering password reset or confirmation flows. Those values are then embedded into the outgoing email workflow without host allowlisting. This creates two related abuse paths:
- password reset or confirmation links can be sent to a victim with the token already attached to an attacker-controlled `forwardToUrl`
- after a legitimate password reset completes, the browser is redirected to attacker-controlled `redirectUrl`
In practice, this can be used for phishing, token capture, confirmation hijacking, or steering a victim from a trusted email
into an attacker domain. This is patched in version 26.06.08.
## Summary
The fix for GHSA-6jxm-fv7w-rw5j (CVE-2026-23845, "Server-Side Request Forgery (SSRF) via HTML Check API"), shipped in mailpit `v1.28.3`, hardened `internal/htmlcheck/css.go::downloadCSSToBytes` with a 5MB size cap, a `text/css` content-type check, login-info stripping in `isValidURL`, and an opt-in `--block-remote-css-and-fonts` config flag — but **did not add the IP-filtering dialer that the same codebase already uses on the two sister SSRF endpoints** (the proxy handler and link-check). At HEAD `8bc966e61834a24c48b4465da418f75e73be0afd` (2026-05-06), `internal/htmlcheck/css.go::newSafeHTTPClient` is mis-named — it builds an `http.Client` whose `Transport.DialContext` calls `net.Dialer.DialContext` directly with no IP allowlisting. As a result, the SSRF originally reported by Bao Anh Phan still permits the server to dial:
- loopback (`127.0.0.0/8`, `::1`),
- private (`10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, `fc00::/7`),
- link-local incl. **cloud IMDS** (`169.254.0.0/16`, especially `169.254.169.254`),
- CGNAT (`100.64.0.0/10`),
- and any other reserved/multicast range,
— provided the target replies with `HTTP/200` and a content-type beginning with `text/css`. With redirect-following (`CheckRedirect` allows redirects to any `isValidURL` URL with no IP filter), an attacker-controlled public site can redirect mailpit's request into the private network without ever appearing in the email's HTML.
In the default mailpit deploy (no UI auth, no SMTP auth, port 1025/8025 exposed), this is an unauthenticated, network-reachable SSRF triggered by sending an HTML email and then issuing one HTTP `GET` to `/api/v1/message/{id}/html-check`.
## Affected versions
- `internal/htmlcheck/css.go` at HEAD `8bc966e61834a24c48b4465da418f75e73be0afd` (2026-05-06).
- All versions `>= v1.28.3` (the version that shipped the GHSA-6jxm fix). Versions `<= v1.28.2` are vulnerable to the original GHSA-6jxm; versions `>= v1.28.3` carry the still-vulnerable variant described here.
## The incomplete fix
The original GHSA-6jxm fix added size+content-type+login-info hardening to `downloadCSSToBytes`. But the dialer it uses still has no `safeDialContext`. The companion `linkcheck` and `proxy` handlers in the same codebase have all-three protections: size cap, content-type/redirect filter, **AND** a `safeDialContext` that runs `tools.IsInternalIP(ip.IP)` per resolved address — same pattern the htmlcheck dialer should adopt.
Side-by-side at HEAD `8bc966e`:
| File | Function | `safeDialContext` (IP filter)? | TOCTOU-safe (dial-by-IP)? |
|---|---|---|---|
| `internal/linkcheck/status.go::safeDialContext` line 140-163 | dial check | YES | YES (resolved IP joined with port) |
| `server/handlers/proxy.go::safeDialContext` line 393-415 | dial check | YES | YES |
| `internal/htmlcheck/css.go::newSafeHTTPClient` line 275-310 | dial check | **NO** | n/a |
The mis-named `newSafeHTTPClient` reads:
```go
// internal/htmlcheck/css.go:275-310
func newSafeHTTPClient() *http.Client {
dialer := &net.Dialer{
Timeout: 5 * time.Second,
KeepAlive: 30 * time.Second,
}
tr := &http.Transport{
Proxy: nil,
DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
return dialer.DialContext(ctx, network, address) // no IP filter
},
...
}
client := &http.Client{
Transport: tr,
Timeout: 15 * time.Second,
CheckRedirect: func(req *http.Request, via []*http.Request) error {
if len(via) >= 3 { return errors.New("too many redirects") }
if !isValidURL(req.URL.String()) { return errors.New("invalid redirect URL") }
return nil
},
}
return client
}
```
`isValidURL` only rejects non-http(s) and userinfo URLs — it does NOT reject internal IPs. Compare `linkcheck/status.go::safeDialContext`:
```go
ips, err := net.DefaultResolver.LookupIPAddr(ctx, host)
...
if !config.AllowInternalHTTPRequests {
for _, ip := range ips {
if tools.IsInternalIP(ip.IP) {
return nil, fmt.Errorf("blocked request to %s (%s): private/reserved address", host, ip)
}
}
}
return dialer.DialContext(ctx, network, net.JoinHostPort(ips[0].IP.String(), port))
```
That's the protection htmlcheck is missing.
## Reachability chain (default deploy)
```
Listen() # config/config.go:36 SMTPListen = "[::]:1025"
↓
SMTP server # internal/smtpd/main.go:222-249 AuthRequired: false, AuthHandler: nil
↓ attacker injects HTML body with <link rel="stylesheet" href="...attacker.com/redirect.css">
↓
storage.Store(...)
↓
Listen() # server/server.go HTTPListen
↓ attacker sends GET /api/v1/message/{id}/html-check
apiv1.HTMLCheck # server/apiv1/other.go:18
↓ no UI auth in default deploy (auth.UICredentials == nil)
htmlcheck.RunTests(msg.HTML)
SurrealDB versions before 3.1.0 have a vulnerability in HTTP redirect handling that allows authenticated users to bypass port-specific --deny-net rules. This occurs because the port information is dropped during redirect policy evaluation, enabling redirects from allowed hostnames to denied host:port combinations to be followed.
A vulnerability in the Linux kernel's network scheduler (net/sched) involving mirred redirect loops between ingress and egress interfaces has been resolved. The issue occurs because the loop detection state is lost due to packet deferral and clearing of the sched_mirred_dev array, preventing discovery of mirred loops. This can cause unexpected network behavior when mirred actions redirect packets between interfaces in a loop. A test case demonstrates the loop creation using traffic control commands and ping. No CVSS score is available for this vulnerability.
@hapi/wreck is an HTTP client utility. Prior to 18.1.2, Wreck strips credential headers including Authorization, Cookie, and Proxy-Authorization before following a cross-origin redirect, but the origin check compares hostnames only and ignores scheme and port, so credentials are forwarded intact across same-host port changes and HTTPS-to-HTTP downgrades, allowing a co-tenant on an adjacent port or a network-position attacker capable of forging a redirect to capture bearer tokens, session cookies, and proxy credentials and impersonate the victim against the upstream service. This issue is fixed in version 18.1.2.
SigNoz versions through 0.133.0 have an open redirect vulnerability in the Single Sign-On (SSO) authentication flow. This flaw allows unauthenticated attackers to steal session tokens from users on instances configured with Google OAuth, SAML, or OIDC. Attackers exploit this by crafting a login URL with a redirect parameter pointing to a malicious host and tricking victims into completing the SSO authentication, thereby capturing their access and refresh tokens.
A flaw was found in the Keycloak keycloak-services component, which handles the management of identity providers. The issue occurs when a delegated administrator updates an OIDC identity provider using a masked client secret sentinel value. Due to improper validation, Keycloak reuses the existing real secret even if security-sensitive fields like the token URL have been changed, allowing an attacker to redirect and capture the secret.
The WooCommerce Placetopay Gateway and PlacetoPay/AvalPay gateway plugins for WordPress are vulnerable to Reflected Cross-Site Scripting via the 'redirect-url' parameter in versions up to, and including, 3.2.2 due to insufficient input sanitization and output escaping. This makes it possible for unauthenticated attackers to inject arbitrary web scripts in pages that execute if they can successfully trick a user into performing an action such as clicking on a link.