The npm package 'dowload_ebok_kosten_und_leistungsrechnung_fur_dummies_by_michael_griga_b29bg' contains malicious code. Installing or running this package can lead to a full compromise of the affected computer. Any secrets or keys stored on the compromised system should be rotated immediately from a different, secure machine. Simply removing the package may not eliminate all malicious software introduced by it.
The npm package 'dowload_ebok_cork_dork_by_bianca_bosker_1fae5' contains malicious code that fully compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected system should be rotated immediately from a different, secure computer. Removal of the package alone does not guarantee elimination of all malicious software introduced by its installation.
The npm package 'dowload_ebok_sydney_noir_by_michael_duffy_nick_hordern_4y353' is identified as malicious software. Any system with this package installed or running is considered fully compromised, potentially allowing an attacker full control. Immediate rotation of all secrets and keys stored on the affected system from a separate, secure machine is strongly advised. Removal of the package is recommended, but it may not fully eliminate the malicious presence due to possible persistent control established by the attacker.
The npm package 'dowload_ebok_la_voz_del_maestro_by_gibran_khalil_gibran_kwgno' contains malicious code that can fully compromise any computer on which it is installed or running. The compromise may allow an attacker to gain full control over the affected system. Immediate removal of the package is advised, but due to the potential extent of the compromise, simply removing the package may not eliminate all malicious components. All secrets and keys stored on the compromised computer should be rotated from a separate, secure device.
Aegis Latent Core is a tamper-evident evidence chain designed to secure AI interaction logs by hash-chaining and signing each event before delivery. It aims to help blue teams detect post-collection tampering of AI traffic logs, preserve forensic artifacts, and support compliance with AI traceability regulations. It does not prevent or detect endpoint compromise or guarantee client honesty, as it starts at the collector. The system is intended as an additional evidence layer rather than a SIEM replacement or producer attestation mechanism.
Missing authentication for a critical function in the Android Debug Bridge daemon (adbd) in DJI CrystalSky ZS600C firmware v0.3.9.7 through v0.6.6.9 allows an attacker to obtain an unauthenticated shell (uid 2000), a foothold for privilege escalation to root. The device ships with ro.adb.secure=0 (no host key authorization) and USB ADB enabled by default; ADB over TCP is not enabled by default but, once enabled (e.g. via the shipped /system/bin/adbd_tcp.sh or 'setprop persist.adb.tcp.port 5555'), the same unauthenticated shell is reachable over the network (CVSS 4.0 base 9.3).
CVE-2026-114642 is a vulnerability in Traefik versions 2.11.0 before 2.11.58 and 3.0.0 before 3.7.14. It involves improper certificate validation due to reuse of TLS client configurations across backend services. An unauthenticated client can exploit this to bypass TLS verification, including root CA checks and server name validation, potentially compromising secure connections between services.
A vulnerability in Go's crypto/x509 package affects Red Hat Hardened Images RPMs, specifically the jaeger package version 2.21.0-0.2.hum1. The certificate verification process does not properly block trust in intermediate certificates linked to compromised Certificate Authorities, allowing a remote attacker to impersonate legitimate servers during secure connections. This flaw can enable man-in-the-middle attacks to intercept or alter confidential communications. The issue is rated as important by Red Hat and affects Go-based clients or servers relying on standard certificate verification.
CVE-2026-101480 is a vulnerability in Oracle Secure Backup's NDMP daemon affecting versions 19.1.0.0.0 and 19.1.0.1.0. It allows an unauthenticated attacker with network access via TCP to gain unauthorized read access to some Oracle Secure Backup data. The vulnerability has a CVSS 3.1 base score of 5.3, indicating a medium severity with confidentiality impact only. No integrity or availability impacts are reported. Oracle has published a Critical Patch Update advisory that includes security patches for multiple products, but no explicit patch link or fixed version for this specific vulnerability is provided in the input data.
Multiple vulnerabilities have been identified in libreswan, an implementation of IPsec and IKE for Linux, which is used to build secure VPN tunnels. These include denial of service issues in IKEv1 and IKEv2 caused by RSA-SHA1 authentication payloads, and an assertion failure triggered by a badly formatted X.509 certificate that crashes the daemon process. Red Hat has issued a security update addressing these issues for Red Hat Enterprise Linux 8.4 variants.
CVE-2026-102061 is a stack-based buffer overflow vulnerability in the phone-home daemon (phcd) of Juniper Networks Junos OS and Junos OS Evolved. It allows an adjacent unauthenticated attacker to execute arbitrary code as root by sending a crafted DHCP SZTP bootstrap message. This vulnerability affects only platforms that support Secure-ZTP. The issue has a high severity with a CVSS score of 8.8.
## Summary
Incomplete fix of GHSA-5v7c-xpfp-p65m: the secure-session (OTP step-up) requirement added to the nginx, cert, dns, backup, site, and stream mutation routers was not applied to the parallel api/cluster router, so cluster node management and cluster-wide nginx reload/restart run with only a JWT and no step-up. An authenticated user whose JWT is stolen or persisted, but who does not hold a fresh secure-session, can perform cluster node CRUD (including reading and rewriting a node token secret) and trigger cluster-wide nginx reload/restart. Confirmed at HEAD 2cb7ee9102c9d87274de2fa104db804841d140a0.
## The defect
GHSA-5v7c-xpfp-p65m required a fresh secure session (an OTP step-up beyond the JWT) for sensitive mutation routes. The fix wrapped the nginx, cert, dns, backup, site, and stream mutation handlers in middleware.RequireSecureSession() and added reload/restart to the MCP sensitive-tool list. It did not touch the physically separate api/cluster package, whose router registers the same class of sensitive operations on the bare authenticated group.
The fixed sibling, api/nginx/router.go:
```go
o := r.Group("", middleware.RequireSecureSession()) // line 28
{
o.POST("nginx/reload", Reload) // line 30
o.POST("nginx/restart", Restart) // line 31
}
```
The missed router, api/cluster/router.go, registers every sensitive operation directly on r with no RequireSecureSession wrapper:
```go
nodeGroup := r.Group("nodes") // line 9, no step-up
{
nodeGroup.POST("", AddNode) // line 12
nodeGroup.POST("/:id", EditNode) // line 13
nodeGroup.DELETE("/:id", DeleteNode) // line 14
}
r.POST("nodes/reload_nginx", ReloadNginx) // line 17
r.POST("nodes/restart_nginx", RestartNginx) // line 18
r.POST("namespaces", AddNamespace) // line 22
r.POST("namespaces/:id", ModifyNamespace) // line 23
r.DELETE("namespaces/:id", DeleteNamespace) // line 24
```
Both routers mount on the same group in router/routers.go: `g := root.Group("/", middleware.AuthRequired(), middleware.Proxy())` (line 87); nginx.InitRouter(g) creates its own RequireSecureSession subgroup, cluster.InitRouter(g) does not. So the cluster routes inherit only AuthRequired and Proxy, exactly the pre-fix posture the advisory closed for the nginx routes. AuthRequired has no role gate, so any authenticated user reaches them.
## Attacker model and impact
An authenticated, OTP-enabled user who does not present a fresh X-Secure-Session-ID (the parent advisory's model: a stolen or persisted JWT used without the step-up). Such a user can: add/edit/delete cluster nodes (AddNode/EditNode store an AES-serialized node token, the secret used to control a remote node, so this reads back and rewrites a cross-node credential); trigger nodes/reload_nginx and nodes/restart_nginx across the cluster (the exact reload/restart action class the fix protected on the single-node path); and add/modify/delete/reorder namespaces.
Proof of concept: with a valid JWT but no fresh secure session, call POST /api/nodes (AddNode) or POST /api/nodes/reload_nginx. The nginx equivalent POST /api/nginx/reload returns the secure-session challenge; the cluster route succeeds.
## Verification
Source-verified at HEAD: the nginx router wraps reload/restart in RequireSecureSession, the cluster router registers node/namespace/reload/restart directly on the group with no such wrapper, and both mount on the AuthRequired+Proxy-only group. I did not stand up a live nginx-ui.
## Suggested fix
Wrap the cluster router's mutation handlers (node CRUD, nodes/reload_nginx, nodes/restart_nginx, namespace CRUD) in middleware.RequireSecureSession(), mirroring api/nginx/router.go. Secondary lower-confidence items worth checking in the same pass: the system/restart handler, the core-upgrade websocket, and the upstream socket PUT also appear to run without the step-up (I did not fully trace these).
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (5cb86188f9853b34c6dc3cf9c8259a789920326e8ddf4ae4cd3566385bba3ea1)
The package presents itself as a dotenv-style environment loader but ships a Windows dropper that fires automatically on module load and on CLI invocation. Both dist/index.cjs (the package main) and dist/cli.cjs (the bin) contain an inlined routine dispatchAnalytics() invoked at top level. That routine reads dist/stest.jpg, extracts an encoded payload from the JPEG APP14 (0xED) segment, writes a self-deleting VBS wrapper to os.tmpdir(), and launches it via wscript.exe to run powershell.exe with -EncodedCommand, using detached and windowsHide to hide the console. The strings 'powershell.exe', 'wscript.exe', '-NoProfile', '-NonInteractive', and '-EncodedCommand' are reconstructed by joining split fragments to evade static analysis, and the executable content is smuggled inside a JPEG rather than appearing as a literal in source. Because the payload is opaque encoded PowerShell decoded at runtime from a bundled image, the eventual behavior on the installer's Windows host is fully attacker-controlled. Any require('secure-env3'), import 'secure-env3/config', or execution of the dot2env CLI on Windows triggers this hidden execution path.
A security vulnerability (CVE-2026-33810) affects the yggdrasil system daemon in Red Hat Enterprise Linux 10.0 Extended Update Support. The flaw is a certificate validation bypass in the Go crypto/x509 package due to incorrect DNS constraint application. This vulnerability could allow improper validation of TLS certificates, potentially undermining secure communications. Red Hat has issued an important security update to address this issue.
OpenIDC cjose versions 0.6.1 through 0.6.2.5 contain a critical vulnerability where the content-encryption key (CEK) used in AES-CBC-HMAC algorithms is hard-coded to all zero bytes instead of being randomly generated. This flaw allows anyone with access to the encrypted JSON Web Encryption (JWE) token to decrypt and modify its contents. The issue is fixed in version 0.6.2.6 by properly generating the CEK using a secure random function. Until upgrading, mitigations include using AES-GCM encryption, supplying a CEK directly, or avoiding the affected encryption algorithms. Data encrypted with the vulnerable versions should be re-encrypted and secrets rotated.
This analysis discusses the emerging threat posed by quantum computing to current public-key cryptographic algorithms such as RSA, ECC, and Diffie-Hellman. Although fully capable quantum computers are not yet available, adversaries are already collecting encrypted data to decrypt later once quantum capabilities mature, a tactic known as "harvest now, decrypt later" (HNDL). Regulatory bodies, including the U.S. government via Executive Order 14412, are mandating accelerated migration to quantum-resistant cryptography and require comprehensive cryptographic inventories. The transition to post-quantum cryptography involves a phased operational strategy including discovery, prioritization, remediation, and verification. Symmetric encryption like AES-256 is expected to remain secure against quantum attacks. The threat is recognized as an operational risk today, necessitating proactive organizational measures.
## Summary
There is a medium severity vulnerability in Traefik's ForwardAuth middleware. Even when configured with `trustForwardHeader: false`, Traefik derives the `X-Forwarded-Port` header sent to the authentication service from the original incoming request instead of the sanitized forwarded request. As a result, an unauthenticated remote attacker can inject an `X-Forwarded-Proto: https` header over a plain HTTP connection and cause Traefik to forward `X-Forwarded-Port: 443` to the auth service, bypassing port-based authorization checks. This is a regression of the incomplete fix for GHSA-6384-m2mw-rf54, which addressed the `X-Forwarded-Proto` and `X-Forwarded-Prefix` spoofing vectors but missed the `X-Forwarded-Port` vector.
## Patches
- https://github.com/traefik/traefik/releases/tag/v2.11.51
- https://github.com/traefik/traefik/releases/tag/v3.6.22
- https://github.com/traefik/traefik/releases/tag/v3.7.6
## 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
The ForwardAuth middleware, even when configured with `trustForwardHeader: false`,
still derives the `X-Forwarded-Port` header sent to the authentication service by
reading the **attacker-controlled** `X-Forwarded-Proto` header from the original
incoming request. This allows an unauthenticated remote attacker to cause Traefik
to forward `X-Forwarded-Port: 443` to the auth service on a plain HTTP connection,
creating an inconsistency that can bypass port-based authorization checks.
### Details
The fix introduced in commit `5e1de2258` (released as part of the April 2026 security
advisory GHSA-6384-m2mw-rf54) correctly strips all X-Forwarded-* headers from the
forwarded auth request when `trustForwardHeader=false`, and reconstructs
`X-Forwarded-Proto` from the actual TLS state of the connection (`req.TLS`).
However, the reconstruction of `X-Forwarded-Port` is delegated to the helper
`forwardedPort(req)` which receives the **original request** (`req`) rather than
the sanitized forward request (`forwardReq`):
```go
// pkg/middlewares/auth/forward.go – writeHeader()
if !trustForwardHeader {
forwardedheaders.DeleteXForwardedHeaders(forwardReq.Header) // strips all X-Fwd-* from forwardReq
}
// ...
if _, ok := forwardReq.Header[forwardedheaders.XForwardedPort]; !ok {
forwardReq.Header.Set(forwardedheaders.XForwardedPort, forwardedPort(req)) // ← req = ORIGINAL
}
// pkg/middlewares/auth/forward.go – forwardedPort()
func forwardedPort(req *http.Request) string {
if _, port, err := net.SplitHostPort(req.Host); err == nil && port != "" {
return port
}
// Reads attacker-controlled header on the ORIGINAL request:
if req.Header.Get(forwardedheaders.XForwardedProto) == "https" || ... {
return "443"
}
if req.TLS != nil {
return "443"
}
return "80"
}
Result when trustForwardHeader=false and attacker sends X-Forwarded-Proto: https
on a plain HTTP connection:
┌──────────────────────────────────┬──────────┬────────┐
│ Header forwarded to auth service │ Expected │ Actual │
├──────────────────────────────────┼──────────┼────────┤
│ X-Forwarded-Proto │ http │ http ✓ │
├──────────────────────────────────┼──────────┼────────┤
│ X-Forwarded-Port │ 80 │ 443 ✗ │
└──────────────────────────────────┴──────────┴────────┘
```
The inconsistency between Proto=http and Port=443 is exploitable against any
authentication service that gates access based on X-Forwarded-Port.
### PoC
Traefik configuration:
```http:
middlewares:
my-auth:
forwardAuth:
address: "http://auth-service/"
trustForwardHeader: false # security setting, but still bypassable
routers:
api:
rule: "PathPrefix(`/api`)"
middlewares:
- my-auth
service: backend
Auth service logic (example victim):
# auth-service checks: only port 443 requests are considered "secure"
port = request.headers.get("X-Forwarded-Port", "80")
proto = request.headers.get("X-Forwarded-Proto", "http")
if port == "443":
return 200 # grant access
return 403
```
Attack:
Plain HTTP connection, no TLS – but spoofs port 443
curl -H "X-Forwarded-Proto: https" http://traefik.example.com/api/admin
Auth service receives X-Forwarded-Port: 443 → grants access
Verification: Enable Traefik debug logging and observe X-Forwarded-Port: 443
in the auth request while the connection is plain HTTP.
### Impact
Any deployment using the ForwardAuth middleware with trustForwardHeader: false where
the downstream authentication service uses X-Forwarded-Port to make authorization
decisions is vulnerable to privilege escalation. An unauthenticated attacker can
bypass port-based s