| CVE |
Vendors |
Products |
Updated |
CVSS v3.1 |
| @fastify/proxy-addr determines which network hops are trusted proxies and backs Fastify's trustProxy setting, so that forwarded headers can be believed. In versions 3.0.0 through 5.1.2, when trustProxy is configured with a zoned IPv6 link-local address, the trust comparison checks only the address bits and ignores the zone identifier, so a host on another link of a multi-homed server that carries the same link-local address is trusted as well. Such an attacker can spoof the X-Forwarded-For, X-Forwarded-Host and X-Forwarded-Proto headers, making the client IP, host and protocol reported by Fastify attacker-chosen values and defeating IP allowlists, rate limiting and audit logging. Exploitation requires a multi-homed server whose trustProxy is a zoned link-local address and an attacker directly on one of its other links; the default configuration and global, private or loopback trust entries are not affected. The issue is fixed in @fastify/proxy-addr 5.1.3, and users should upgrade to 5.1.3 or later. As a workaround, avoid trusting a zoned link-local address on a multi-homed host and trust a global, private or loopback proxy address instead. |
| The Multi Step for Contact Form 7 plugin for WordPress is vulnerable to Stored Cross-Site Scripting via the 'multipart field name (array key)' parameter in all versions up to, and including, 2.9.1 due to insufficient input sanitization and output escaping. This makes it possible for unauthenticated attackers to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. Successful exploitation requires the target CF7 form to have the 'Save every step' option enabled and the Database for Contact Form 7 companion plugin to be active with its 'Expandable' table option enabled, both of which are disabled by default. |
| Dell PowerScale InsightIQ, versions 6.3.0 through 6.4.0, containsan Insertion of Sensitive Information into Log File vulnerability. A low privileged attacker with remote access could potentially exploit this vulnerability, leading to Information disclosure. |
| The Libreswan IKEv2 state machine did not verify that an IKE_INTERMEDIATE exchange was required to satisfy the addke= PostQuantum algorithm component of the exchange. A connecting client could (maliciously or by implementation error) skip the IKE_INTERMEDIATE exchange and start an IKE_AUTH exchange prematurely. The result is as if the addke= option had not been specified, and such connections are only protected by the classic key exchange algorithm (such as P-256 or Curve25519), allowing "store now, decrypt later" attacks once a quantum computer becomes available. Only connections with the addke= keyword in the ike= and/or esp= configuration option are affected. PostQuantum Hybrid Key Exchange support was added in version 5.4. |
| Eclipse Kura downloads deployment packages (DPs) from a remote URL without any limit on the size of the data it receives. A malicious or compromised HTTP(S) server, or an attacker able to tamper with a plain-HTTP download, can stream an arbitrarily large (or endless) response. Kura writes the response to local storage until the filesystem is full. On gateways the temporary directory is often a RAM-backed tmpfs, so this can also exhaust memory. The result is denial of service of the device: failed configuration persistence, failed logging and possible crashes of the framework or other services.
The same missing size limit is present in the REST upload endpoint `POST /deploy/v2/_upload`, which copies the request body to the temporary directory with no limit.
Workarounds: only install DPs from trusted HTTPS sources, restrict who can install packages (Web UI `kura.packages.admin` permission, REST `kura.permission.rest.deploy`, cloud DEPLOY-V2 access). |
| The Libreswan pluto daemon dereferences a NULL pointer when a CERT payload is received with an empty PKCS#7 payload, causing the daemon to crash and restart. The NSS function SEC_PKCS7GetCertificateList() was used to check whether the content was empty, but this check did not trigger if the non-empty content of the PKCS#7 wrapped payload was an empty list. Continued triggering of this vulnerability can lead to a denial of service. Remote code execution is not possible. Authentication is not required to trigger this vulnerability. |
| IBM ContextForge MCP Gateway 1.0.0 through 1.0.11 could allow an authenticated caller to bypass upstream credential-level authorization policies due to an insufficiently specific cache key in the RFC 8693 token exchange cache, enabling reuse of cached upstream bearer tokens across different credentials belonging to the same user. |
| TELLUS and TELLUS Lite provided by FUJI ELECTRIC CO., LTD. contain a use after free vulnerability. Opening a specially crafted V9 file may lead to information exposure or arbitrary code execution on the affected product. |
| TELLUS and TELLUS Lite provided by FUJI ELECTRIC CO., LTD. contain an out-of-bounds read vulnerability. Opening a specially crafted V9 file may lead to information exposure or arbitrary code execution on the affected product. |
| Dell PowerStore contains an improper input validation vulnerability. An authenticated low-privileged attacker could exploit this vulnerability, potentially leading to stored cross-site scripting in the management interface. |
| Dell PowerStore contains an integer overflow vulnerability. An adjacent attacker could exploit it to bypass volume bounds checks, potentially leading to data destruction or denial of service. |
| LibreOffice can embed audio and video in documents. Where it plays media with GStreamer, as on Linux, the media is opened when the document is loaded, and a preview image of a video is shown in the document and in its exports, such as PDF. A crafted media file could make GStreamer read a local file and draw its text into the preview image, so that the content of the file ended up in an exported document. This is a different route to the problem fixed for CVE-2026-63269. In fixed versions GStreamer opens only media in a short list of common, self-contained container formats. |
| LibreOffice documents can contain Basic macro libraries. A library protected by a password is stored in the document in a compiled form, which may be read when the document is loaded. An out-of-bounds write existed when the compiled form was read, because the positions of its strings were not checked against the size of the data they refer to, and a type found by name was not checked to be of the right kind. In fixed versions these positions are checked, a library that fails the check is not loaded, and a type of the wrong kind is ignored. |
| LibreOffice Writer can open HTML documents, and an HTML document can bind macros to events of the document as a whole, such as the document being opened or closed. Macros bound to these events were not taken into account by the macro security check, so they could run when the document was opened, whatever the macro security level. In fixed versions these macros follow the macro security settings like any other macro in the document. |
| LibreOffice documents can contain Basic macro libraries. A library protected by a password is stored in the document in a compiled form, which may be read when the document is loaded. When a value in the compiled form used an older record format, it could be read as a different type from the one the existing value held, which corrupted memory. In fixed versions the existing value is cleared before a value in the older format is read. |
| An out-of-bounds read vulnerability in the IOMMU could allow a malicious guest to corrupt hypervisor (HV) pages and potentially cause a host crash leading to loss of availability. |
| A vulnerability in the default configuration of vsomeip allows a remote, unauthenticated attacker to trigger massive memory allocations by sending a small TCP packet with a large, attacker-declared SOME/IP length field. This can lead to immediate service termination via OOM-kill on memory-constrained systems or total host memory exhaustion through repeated connections. |
| In the Linux kernel, the following vulnerability has been resolved:
KVM: arm64: nv: Fix SPSR_EL2 restore in kvm_hyp_handle_mops()
kvm_hyp_handle_mops() resets the single-step state machine as part of
rewinding state for a MOPS exception by modifying vcpu_cpsr() and
writing the result directly into hardware.
In the case of nested virtualization, vcpu_cpsr() is a synthetic value
such that the rest of KVM can deal with vEL2 cleanly. That means the
value requires translation before being written into hardware, which is
unfortunately missing from the MOPS handler.
Fix it by directly modifying SPSR_EL2 and avoiding the synthetic state
altogether, which will be resynchronized on the next 'full' exit back
to KVM. |
| In the Linux kernel, the following vulnerability has been resolved:
KVM: x86: wean fast IN from emulator_pio_in
Use __emulator_pio_in() directly for fast PIO instead of bouncing through
emulator_pio_in() now that __emulator_pio_in() fills "val" when handling
in-kernel PIO. vcpu->arch.pio.count is guaranteed to be '0', so this a
pure nop.
emulator_pio_in_emulated is now the last caller of emulator_pio_in.
No functional change intended. |
| In the Linux kernel, the following vulnerability has been resolved:
Input: ims-pcu - fix heap-buffer-overflow in ims_pcu_process_data()
The `ims_pcu_process_data()` processes incoming URB data byte by byte.
However, it fails to check if the `read_pos` index exceeds
IMS_PCU_BUF_SIZE.
If a malicious USB device sends a packet larger than IMS_PCU_BUF_SIZE,
`read_pos` will increment indefinitely. Moreover, since `read_pos` is
located immediately after `read_buf`, the attacker can overwrite
`read_pos` itself to arbitrarily control the index.
This manipulated `read_pos` is subsequently used in
`ims_pcu_handle_response()` to copy data into `cmd_buf`, leading to a
heap buffer overflow.
Specifically, an attacker can overwrite the `cmd_done.wait.head` located
at offset 136 relative to `cmd_buf` in the `ims_pcu_handle_response()`.
Consequently, when the driver calls `complete(&pcu->cmd_done)`, it
triggers a control flow hijack by using the manipulated pointer.
Fix this by adding a bounds check for `read_pos` before writing to
`read_buf`. If the packet is too long, discard it, log a warning,
and reset the parser state.
[dtor: factor out resetting packet state, reset checksum as well] |