The npm package 'china_airlines' version 1.0.0 contains no legitimate JavaScript library code but instead hosts a heavily obfuscated phishing landing page disguised as a Cloudflare interstitial. It uses obfuscated JavaScript to redirect users visiting the package via public CDN mirrors to a malicious target URL, abusing npm and CDN infrastructure for phishing. The package itself does not execute malicious code during installation or import, so it does not directly compromise developer machines through install-time code execution. However, browsers visiting the hosted page can be redirected to phishing sites. According to one source, any computer with this package installed should be considered fully compromised, though this claim conflicts with the inert install surface described. No official patch or remediation is documented.
The npm package 'hngfykuvgh4' version 1.0.0 is a malicious artifact that impersonates a Cloudflare verification page using an obfuscated script to redirect visitors to a hidden destination URL. It does not execute code during installation or import, abusing the npm registry as static hosting for a phishing or redirect lure. While it is not a supply-chain attack against developers' build systems, any computer with this package installed should be considered fully compromised, requiring immediate secret and key rotation and package removal.
The npm package 'jkbnwsdf8' contains a single HTML file styled as a Cloudflare Turnstile challenge that executes obfuscated JavaScript to redirect browser users to a constructed URL. This redirect only triggers when the HTML is loaded via an npm CDN in a browser, not during package installation or require() in Node.js environments. The package abuses npm as a static-hosting CDN for redirect/cloaking purposes and does not execute code on the installer's machine. However, another source claims that any system with this package installed or running should be considered fully compromised, recommending immediate secret/key rotation and package removal. No official patch or remediation guidance is provided.
A flaw was found in multicloud-integrations, a component of Red Hat Advanced Cluster Management (RHACM). This vulnerability allows an authenticated user, referred to as a tenant, to manipulate the GitOpsCluster controller. By exploiting this, a tenant can redirect sensitive spoke cluster bearer tokens from secure locations to a namespace they control. This unauthorized access to tokens can lead to the disclosure of critical information and bypass security policies within ArgoCD AppProjects.
A flaw was found in insights-client. A compromised managed cluster, referred to as a 'spoke', can inject unencoded data into the Insights API URL path. This occurs because the ClusterID, which is controlled by the spoke, is used directly in the request path without proper validation or URL encoding. This vulnerability allows a malicious spoke to redirect authenticated requests to unintended API endpoints, potentially leading to information disclosure or unauthorized access.
A flaw was found in the oauth-server component. This open redirect vulnerability occurs when the 'then' parameter in the grant approval handler is not properly validated. A remote attacker can craft a malicious URL that, when approved or denied by an authenticated user, redirects them to an attacker-controlled website. This could enable phishing attacks, potentially tricking users into revealing sensitive information.
A broken access control vulnerability in Peppermint Lab Peppermint through commit ba6e217 allows any authenticated non-administrative user to reconfigure the platform global OIDC/SSO settings via an unprotected configuration endpoint. The endpoint performs no administrative role check before applying new OIDC issuer settings. An attacker can redirect all SSO logins to an attacker-controlled identity provider, enabling credential harvesting for all platform users.
CVE-2026-64941 is an open redirect vulnerability in phoenixframework's phoenix_live_view component. The vulnerability arises because the redirect/2 function improperly validates the :to parameter, allowing ASCII tab, LF, or CR characters that browsers strip before URL parsing. This enables attackers to redirect users to arbitrary external sites. The issue affects multiple versions before fixed releases and has a low CVSS score indicating limited impact.
Home Assistant is open source home automation software focused on local control and privacy. Prior to 2026.6.1, the Android Companion app is vulnerable to an open redirect. The app passes the URL fragment from a homeassistant://invite deep link into the onboarding flow without ever displaying the destination hostname. Because no screen in the invitation or onboarding flow shows the parsed server URL before onboarding commits to it, a victim has no way to distinguish a legitimate invite from a malicious one. An attacker can craft an invite so that a single tap on the legitimate-looking "Connect to my Home Assistant server" button opens their /auth/authorize endpoint in the URL-less onboarding WebView, presenting a look-alike login page that captures the victim's credentials. Since invitations are intended to onboard brand-new users, targets are especially unlikely to notice the substitution. This issue is fixed in version 2026.6.1.
Gen's H1 2026 Threat Report examines two separate attack chains. One used compromised business inboxes and browser manipulation in a banking-malware campaign, while the other used clipboard hijacking to redirect cryptocurrency payments. [...]
The Webbox of TeamDavid by Tobit Laboratories AG constructs redirect URLs using user-supplied input,
which is appended to the redirect target in a 302 HTTP response. By
using URL-encoded characters such as “%2e” (representing a dot), an
attacker can manipulate the portion of the URL following the top-level
domain (TLD). If a similar, registerable TLD exists (for example, if
“.com” is the application’s domain, and “.company” is available for
registration), an attacker can craft a URL to redirect users to a
malicious “.company” domain. By using URL-encoded line feeds, it becomes
possible to insert arbitrary response headers in the server's HTTP
response.
This issue affects TeamDavid before Rollout 528.
Starting with Rollout 528 (June 30, 2026), the affected functionality is disabled by default and the vulnerabilities are therefore no longer exposed through this functionality.
## Summary
There is a high severity vulnerability in Traefik's Kubernetes Gateway API provider. Router and service identities for `HTTPRoute`, `GRPCRoute`, `TCPRoute` and `TLSRoute` objects were built by hyphen-concatenating the route namespace, the route name, the Gateway identity, the entry point and the rule index, a construction that is not injective because Kubernetes names may themselves contain hyphens. Two distinct Routes attached to the same Gateway with equivalent match rules can therefore produce the same identity, and the Route loaded later silently overwrites the earlier one, so a tenant able to create an accepted Route in a colliding namespace/name combination can redirect another namespace's traffic to a backend it controls. All Traefik v3 minor lines are affected; the lines older than v3.6 are no longer maintained and will not receive a patch of their own, so users running them should upgrade to a maintained, patched release.
## Patches
- https://github.com/traefik/traefik/releases/tag/v3.6.25
- https://github.com/traefik/traefik/releases/tag/v3.7.10
## 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
Traefik's Kubernetes Gateway provider constructs internal HTTPRoute and
GRPCRoute identities by concatenating namespace, route name, Gateway identity,
entrypoint, and rule index with hyphens. Kubernetes names may themselves
contain hyphens, so the construction is not injective.
For example, HTTPRoutes `team/a-app` and `team-a/app`, attached to the same
Gateway with the same match rule, produce identical router and service keys.
During configuration merging, the route loaded later overwrites the earlier
route's maps. A tenant that can create an accepted Route in a colliding
namespace/name combination can therefore redirect another namespace's
traffic to an attacker-controlled backend.
The official v3.7.8 binary was reproduced returning the victim backend before
the second Route was created and the attacker backend immediately afterward.
The victim Route had the earlier creation timestamp and should win the
equivalent-match conflict under Gateway API precedence rules.
## Details
The HTTPRoute provider creates a route key as follows:
```go
routeKey := provider.Normalize(fmt.Sprintf(
"%s-%s-%s-gw-%s-%s-ep-%s-%d",
strings.ToLower(kindHTTPRoute),
route.Namespace,
route.Name,
gatewayNamespace,
gatewayName,
listener.EPName,
ri,
))
```
`Normalize` replaces non-alphanumeric runs with `-`, but it does not encode
field lengths or otherwise preserve component boundaries:
```go
func Normalize(name string) string {
fargs := func(c rune) bool {
return !unicode.IsLetter(c) && !unicode.IsNumber(c)
}
return strings.Join(strings.FieldsFunc(name, fargs), "-")
}
```
These distinct objects therefore have the same normalized key:
```text
namespace=team, route=a-app
namespace=team-a, route=app
httproute-team-a-app-gw-gateway-shared-ep-web-0
```
`makeRouterName` adds a hash of the routing rule. When the attacker copies the
victim's hostname and path, that hash is also identical. Child service and
middleware names are derived from the same parent identity.
Each Route is built into a temporary configuration and then merged into the
provider-wide configuration with `maps.Copy`:
```go
maps.Copy(to.HTTP.Routers, from.HTTP.Routers)
maps.Copy(to.HTTP.Middlewares, from.HTTP.Middlewares)
maps.Copy(to.HTTP.Services, from.HTTP.Services)
maps.Copy(to.HTTP.ServersTransports, from.HTTP.ServersTransports)
```
`maps.Copy` replaces an existing value for a duplicate key. No collision is
reported, and the resulting router points to the later Route's backend. The
GRPCRoute implementation uses the same delimiter-free route-key format and
the same HTTP configuration merge path.
### Attack prerequisites
The attacker needs permission to create or modify an HTTPRoute or GRPCRoute
that the shared Gateway accepts. Exploitation also requires namespace and
Route names whose concatenation collides with a victim. The attacker does not
need permission to read or modify the victim Route, Service, or namespace.
## Proof of Concept
Prerequisites:
- a disposable Kubernetes cluster with Gateway API v1.5.1 experimental CRDs;
- `kubectl` configured for that cluster;
- curl;
- local TCP port 18080 available.
The following script embeds all objects used by the reproduction. It runs the
official `traefik:v3.7.8` image, creates the victim Route first, verifies the
victim backend, then creates the colliding attacker Route and repeats the
request.
```bash
#!/usr/bin/env bash
set -euo pipefail
kubectl apply -f - <<'YAML'
apiVersion: v1
kind: Namespace
metadata:
name: gateway
---
apiVersion: v1
kind: Namespace
metadata:
name: team
---
apiVersion: v1
kind: Namespace
metadata:
name: team-a
---
apiVersion: v1
kind: ServiceAccount
metadata:
name: traefik-audit
Ground Station prior to 0.6.0 contains an unauthenticated database-destruction and arbitrary-data-injection vulnerability in the Socket.IO server's database_backup event handler that allows any unauthenticated network peer to wipe or replace the entire SQLite database by sending a single full_restore command with a caller-supplied SQL blob. Attackers can connect to the Socket.IO server on port 7000 without credentials due to disabled authentication enforcement and a wildcard CORS policy, then emit the database_backup event to drop every existing table and recreate the database from attacker-controlled CREATE TABLE and INSERT INTO statements executed via raw exec_driver_sql, permanently destroying all satellite records, orbital sources, hardware configurations, and observation schedules, or planting fabricated orbital-source URLs and observation entries that redirect the ground station to attacker-controlled servers on the next scheduled sync.
When a proxy server is configured with `customUrl.enabled`, the component accepts user-supplied input within forwarded HTTP headers without enforcing expected validation constraints. A malicious actor can manipulate these headers to influence the URL construction process, leading to an open redirect vulnerability. Additionally, unsanitized header values are written to application logs.
An attacker can exploit this to force redirection to arbitrary malicious domains, potentially enabling phishing attacks. Furthermore, they can inject forged entries into application logs, impacting the reliability of security logs and potentially hindering incident investigation.
Red Hat has released security updates for the Red Hat build of Keycloak 26.6.5, addressing multiple vulnerabilities including authorization bypasses, privilege escalation, denial of service, arbitrary code execution, and security bypasses in various components such as the admin UI, FGAPv2, DCR protocol, LDAP user search, Quarkus REST, SAML broker, and OIDC redirect URI. These vulnerabilities affect the OpenShift containerized image and operator for on-premise or private cloud deployments. The update aligns with the standalone Keycloak product release and provides new container images to mitigate these issues.
DjangoCRM's toggle_default_sorting view is the only route in common/urls.py that is not wrapped in login_required or staff_member_required, and it redirects to a caller-supplied next_url GET parameter after only checking secure_url(next_url), which merely verifies the target host matches the current site's domain (blocking only cross-domain redirects) while allowing any same-site path with no authentication required to reach the view.
An open redirect vulnerability exists in kalcaddle kodbox 1.67 Build 02 within the SSO API Login component. The vulnerability arises from improper handling of the callbackUrl parameter in the /user/sso/apiLogin endpoint, allowing attackers to redirect users to arbitrary external URLs. The issue can be exploited remotely and has been publicly disclosed. The vendor has not responded to the disclosure, and no official patch or remediation guidance is currently available.