huzaifas-sidhpurwala/RedHat-security-VeX huggingface dataset:
net: pktgen: fix access outside of user given buffer in pktgen_thread_write()
CVE: CVE-2025-38061
Component: kernel
Severity: Moderate
CVSS v3: 7.4/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
Release date: 2025-06-18T00:00:00+00:00

In the Linux kernel, the following vulnerability has been resolved:

net: pktgen: fix access outside of user given buffer in pktgen_thread_write()

Honour the user given buffer size for the strn_len() calls (otherwise
strn_len() will access memory outside of the user given buffer).

Statement: This fix bounds the parsed input to the user‑supplied buffer size, preventing out‑of‑range reads in pktgen_thread_write(). Note that only privileged users can write to /proc/net/pktgen/*, so exploitation requires local root access.

Remediation:
Unauthenticated SSRF via Realm‑Controlled DNS SRV
CVE: CVE-2025-59088
Component: python-kdcproxy
CWE: CWE-918
Severity: Important
CVSS v3: 8.5/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N
Release date: 2025-11-12T00:00:00+00:00

If kdcproxy receives a request for a realm which does not have server addresses defined in its configuration, by default, it will query SRV records in the DNS zone matching the requested realm name. This creates a server-side request forgery vulnerability, since an attacker could send a request for a realm matching a DNS zone where they created SRV records pointing to arbitrary ports and hostnames (which may resolve to loopback or internal IP addresses). This vulnerability can be exploited to probe internal network topology and firewall rules, perform port scanning, and exfiltrate data. Deployments where
the "use_dns" setting is explicitly set to false are not affected.


Remediation:
To mitigate this issue before a final fix can be applied, set "use_dns" parameter to false in the global section of the kdcproxy.conf file. This will disable the use of DNS to find Active Directory servers so it may break the service if DNS is needed.
EDK2: Improper Input Validation allows arbitrary command execution
CVE: CVE-2025-2296
Component: edk2
CWE: CWE-20
Severity: Important
CVSS v3: 7.4/AV:L/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H
Release date: 2025-12-09T15:00:48.437000+00:00

A flaw was found in EDK2 (EFI Development Kit 2). This vulnerability allows an attacker to cause arbitrary command execution and impact Confidentiality, Integrity, and Availability via improper input validation by local access.

Statement: This vulnerability is considered Important because it compromises a key security control in the boot chain, Secure Boot enforcement—by allowing an unsigned kernel to be loaded through the legacy fallback path when direct-boot signature verification fails. Although exploitation requires high privileges, the flaw enables a reliable and unintended bypass of a protection mechanism explicitly designed to prevent unauthorized code from executing during early boot. This loss of integrity in a security-critical stage gives attackers the opportunity to introduce persistent modifications, tamper with system state, or load manipulated kernels outside the trusted key database. The impact is therefore more significant than a moderate flaw, as it affects a foundational trust anchor rather than a user-space component, and can meaningfully weaken the platform’s security posture even under restricted privilege conditions.

Remediation:
To reduce the risk by disabling direct-boot mode, ensuring all bootable kernels are signed and present in the Secure Boot DB, and restricting privileged access to prevent attackers from introducing unsigned payloads.
GitLab: Cross-Site Scripting Vulnerability Leading to Arbitrary Code Execution
CVE: CVE-2025-13761
Component: gitlab
CWE: CWE-79
Severity: Important
CVSS v3: 8.0/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:N
Release date: 2025-01-01T00:00:00+00:00

A flaw was found in GitLab. This Cross-Site Scripting (XSS) vulnerability allows an unauthenticated attacker to execute arbitrary code in the context of an authenticated user's browser. This occurs when a legitimate user is convinced to visit a specially crafted webpage, potentially leading to compromised user sessions or data.


Remediation:
Linux kernel: Denial of Service in SMB client due to native symlink handling
CVE: CVE-2025-38431
Component: kernel
CWE: CWE-59
Severity: Moderate
CVSS v3: 5.6/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
Release date: 2025-07-25T00:00:00+00:00

In the Linux kernel, the following vulnerability has been resolved:

smb: client: fix regression with native SMB symlinks

Some users and customers reported that their backup/copy tools started
to fail when the directory being copied contained symlink targets that
the client couldn't parse - even when those symlinks weren't followed.

Fix this by allowing lstat(2) and readlink(2) to succeed even when the
client can't resolve the symlink target, restoring old behavior.


Remediation:
btrfs: ensure no dirty metadata is written back for an fs with errors
CVE: CVE-2025-40303
Component: kernel
CWE: CWE-459
Severity: Low
CVSS v3: 3.4/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:L
Release date: 2025-12-08T00:00:00+00:00

In the Linux kernel, the following vulnerability has been resolved:

btrfs: ensure no dirty metadata is written back for an fs with errors

[BUG]
During development of a minor feature (make sure all btrfs_bio::end_io()
is called in task context), I noticed a crash in generic/388, where
metadata writes triggered new works after btrfs_stop_all_workers().

It turns out that it can even happen without any code modification, just
using RAID5 for metadata and the same workload from generic/388 is going
to trigger the use-after-free.

[CAUSE]
If btrfs hits an error, the fs is marked as error, no new
transaction is allowed thus metadata is in a frozen state.

But there are some metadata modifications before that error, and they are
still in the btree inode page cache.

Since there will be no real transaction commit, all those dirty folios
are just kept as is in the page cache, and they can not be invalidated
by invalidate_inode_pages2() call inside close_ctree(), because they are
dirty.

And finally after btrfs_stop_all_workers(), we call iput() on btree
inode, which triggers writeback of those dirty metadata.

And if the fs is using RAID56 metadata, this will trigger RMW and queue
new works into rmw_workers, which is already stopped, causing warning
from queue_work() and use-after-free.

[FIX]
Add a special handling for write_one_eb(), that if the fs is already in
an error state, immediately mark the bbio as failure, instead of really
submitting them.

Then during close_ctree(), iput() will just discard all those dirty
tree blocks without really writing them back, thus no more new jobs for
already stopped-and-freed workqueues.

The extra discard in write_one_eb() also acts as an extra safenet.
E.g. the transaction abort is triggered by some extent/free space
tree corruptions, and since extent/free space tree is already corrupted
some tree blocks may be allocated where they shouldn't be (overwriting
existing tree blocks). In that case writing them back will further
corrupting the fs.


Remediation:
Denial of service in Entr'ouvert Lasso
CVE: CVE-2025-46404
Component: lasso
CWE: CWE-476
Severity: Moderate
CVSS v3: 4.2/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L
Release date: 2025-11-05T14:56:59.671000+00:00

A denial of service vulnerability exists in the lasso_provider_verify_saml_signature functionality of Entr&#39;ouvert Lasso 2.5.1. A specially crafted SAML response can lead to a denial of service. An attacker can send a malformed SAML response to trigger this vulnerability.

Statement: This flaw describes an availability impact which is limited on Red Hat products to the active application.

Remediation:
Mitigation for this issue is either not available or the currently available options do not meet the Red Hat Product Security criteria comprising ease of use and deployment, applicability to widespread installation base or stability.
integer buffer overflow causing a segfault when parsing crafted JSON
CVE: CVE-2025-40929
Component: Cpanel-JSON-XS
CVSS v3: 7.5/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Release date: 2025-09-08T15:08:52.327000+00:00

A flaw was found in the Cpanel-JSON-XS Perl module. A buffer overflow can be triggered due to an integer overflow when a specially crafted JSON input is processed, causing a segmentation fault, crashing the application using the module and resulting in a denial of service.

Statement: Red Hat Product Security has determined that this vulnerability does not affect any currently supported Red Hat product. This assessment may evolve based on further analysis and discovery. For more information about this vulnerability and the products it affects, please see the linked references.

Remediation:
LlamaIndex SQL Injection Vulnerability
CVE: CVE-2025-1793
Component: llama-index
CWE: CWE-89
Severity: Important
CVSS v3: 9.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N
Release date: 2025-06-05T04:54:47.071000+00:00

A flaw was found in llama-index. SQL injection vulnerabilities exist within multiple vector store integrations in version v0.12.21, allowing an attacker to execute arbitrary SQL queries. This issue enables unauthorized reading and writing of data via crafted SQL commands. Successful exploitation can lead to data breaches and potential compromise of data belonging to other users, which can be triggered remotely without authentication.

Statement: Ansible LightSpeed does not use Ollama-index and is not installed in this image, therefore this product is not vulnerable by this flaw.

Remediation:
Mitigation for this issue is either not available or the currently available options do not meet the Red Hat Product Security criteria comprising ease of use and deployment, applicability to widespread installation base or stability.
CVE: CVE-2025-2015
Component: Ashlar-Vellum Cobalt VS File Parsing Type Confusion Remote Code Execution Vulnerability
Release date: 2025-03-10T22:00:50.525000+00:00

Ashlar-Vellum Cobalt VS File Parsing Type Confusion Remote Code Execution Vulnerability. This vulnerability allows remote attackers to execute arbitrary code on affected installations of Ashlar-Vellum Cobalt. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file.

The specific flaw exists within the parsing of VS files. The issue results from the lack of proper validation of user-supplied data, which can result in a type confusion condition. An attacker can leverage this vulnerability to execute code in the context of the current process. Was ZDI-CAN-25236.

Statement: Red Hat Product Security has determined that this vulnerability does not affect any currently supported Red Hat product. This assessment may evolve based on further analysis and discovery. For more information about this vulnerability and the products it affects, please see the linked references.

Remediation:
wifi: p54: prevent buffer-overflow in p54_rx_eeprom_readback()
CVE: CVE-2025-38348
Component: kernel
Severity: None
Release date: 2025-07-10T00:00:00+00:00

In the Linux kernel, the following vulnerability has been resolved:

wifi: p54: prevent buffer-overflow in p54_rx_eeprom_readback()

Robert Morris reported:

|If a malicious USB device pretends to be an Intersil p54 wifi
|interface and generates an eeprom_readback message with a large
|eeprom->v1.len, p54_rx_eeprom_readback() will copy data from the
|message beyond the end of priv->eeprom.
|
|static void p54_rx_eeprom_readback(struct p54_common *priv,
|                                   struct sk_buff *skb)
|{
|        struct p54_hdr *hdr = (struct p54_hdr *) skb->data;
|        struct p54_eeprom_lm86 *eeprom = (struct p54_eeprom_lm86 *) hdr->data;
|
|        if (priv->fw_var >= 0x509) {
|                memcpy(priv->eeprom, eeprom->v2.data,
|                       le16_to_cpu(eeprom->v2.len));
|        } else {
|                memcpy(priv->eeprom, eeprom->v1.data,
|                       le16_to_cpu(eeprom->v1.len));
|        }
| [...]

The eeprom->v{1,2}.len is set by the driver in p54_download_eeprom().
The device is supposed to provide the same length back to the driver.
But yes, it's possible (like shown in the report) to alter the value
to something that causes a crash/panic due to overrun.

This patch addresses the issue by adding the size to the common device
context, so p54_rx_eeprom_readback no longer relies on possibly tampered
values... That said, it also checks if the "firmware" altered the value
and no longer copies them.

The one, small saving grace is: Before the driver tries to read the eeprom,
it needs to upload >a< firmware. the vendor firmware has a proprietary
license and as a reason, it is not present on most distributions by
default.


Remediation:
thunderbird: Mitigation bypass in the DOM: Security component
CVE: CVE-2025-13018
Component: firefox
CWE: CWE-79
Severity: Moderate
CVSS v3: 6.0/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N
Release date: 2025-11-11T15:47:16.458000+00:00

A flaw was found in Firefox and Thunderbird. The Mozilla Foundation's Security Advisory describes the following issue: Mitigation bypass in the DOM: Security component.

Statement: Red Hat Product Security rates the severity of this flaw as determined by the Mozilla Foundation Security Advisory.

Remediation:
mailbox: zynqmp-ipi: Fix out-of-bounds access in mailbox cleanup loop
CVE: CVE-2025-40180
Component: kernel
Severity: None
Release date: 2025-11-12T00:00:00+00:00

In the Linux kernel, the following vulnerability has been resolved:

mailbox: zynqmp-ipi: Fix out-of-bounds access in mailbox cleanup loop

The cleanup loop was starting at the wrong array index, causing
out-of-bounds access.
Start the loop at the correct index for zero-indexed arrays to prevent
accessing memory beyond the allocated array bounds.


Remediation:
Denial of Service Vulnerability in Oracle MySQL Server Privilege Management
CVE: CVE-2025-21493
Component: mysql
CWE: CWE-404
Severity: Moderate
CVSS v3: 4.9/AV:N/AC:H/PR:H/UI:N/S:U/C:N/I:N/A:H
Release date: 2025-01-21T20:52:53.419000+00:00

A flaw was found in Oracle's MySQL Server component: Security: Privileges. This vulnerability allows a high-privileged attacker to cause a denial of service, which causes frequent crashes or hangs via network access using multiple protocols.


Remediation:
Insecure Temporary File Handling in run-llama/llama_index
CVE: CVE-2025-7647
Component: llama-index-core
CWE: CWE-378
Severity: Important
CVSS v3: 8.4/AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Release date: 2025-09-27T16:34:36.938000+00:00

A flaw was found in llama-index-core where the get_cache_dir() function creates a hardcoded /tmp/llamda_index directory without secure permissions or user isolation. On Linux systems with multiple users, this allows attackers to steal cached models, poison embeddings, or perform symlink attacks leading to information disclosure or data corruption.

Statement: The impact is IMPORTANT because this flaw affects confidentiality, integrity and availability. An attacker on the same vulnerable system can copy cached model files, poison embeddings to manipulate AI outputs, or create symlinks to overwrite important files. The issue exists in all versions up to and including 0.12.44 and is caused by insecure temporary directory creation and missing permission controls in /tmp.

Remediation:
Red Hat Ansible Automation Platform
fuse: fix io-uring list corruption for terminated non-committed requests
CVE: CVE-2025-68805
Component: kernel
Severity: None
Release date: 2025-01-01T00:00:00+00:00

In the Linux kernel, the following vulnerability has been resolved:

fuse: fix io-uring list corruption for terminated non-committed requests

When a request is terminated before it has been committed, the request
is not removed from the queue's list. This leaves a dangling list entry
that leads to list corruption and use-after-free issues.

Remove the request from the queue's list for terminated non-committed
requests.


Remediation:
io_uring/net: fix io_req_post_cqe abuse by send bundle
CVE: CVE-2025-23154
Component: kernel
CWE: CWE-665
Severity: Low
CVSS v3: 5.1/AV:L/AC:L/PR:H/UI:N/S:U/C:N/I:N/A:H
Release date: 2025-05-01T00:00:00+00:00

In the Linux kernel, the following vulnerability has been resolved:

io_uring/net: fix io_req_post_cqe abuse by send bundle

[  114.987980][ T5313] WARNING: CPU: 6 PID: 5313 at io_uring/io_uring.c:872 io_req_post_cqe+0x12e/0x4f0
[  114.991597][ T5313] RIP: 0010:io_req_post_cqe+0x12e/0x4f0
[  115.001880][ T5313] Call Trace:
[  115.002222][ T5313]  <TASK>
[  115.007813][ T5313]  io_send+0x4fe/0x10f0
[  115.009317][ T5313]  io_issue_sqe+0x1a6/0x1740
[  115.012094][ T5313]  io_wq_submit_work+0x38b/0xed0
[  115.013223][ T5313]  io_worker_handle_work+0x62a/0x1600
[  115.013876][ T5313]  io_wq_worker+0x34f/0xdf0

As the comment states, io_req_post_cqe() should only be used by
multishot requests, i.e. REQ_F_APOLL_MULTISHOT, which bundled sends are
not. Add a flag signifying whether a request wants to post multiple
CQEs. Eventually REQ_F_APOLL_MULTISHOT should imply the new flag, but
that's left out for simplicity.


Remediation:
axios-cache-interceptor Vulnerable to Cache Poisoning via Ignored HTTP Vary Header
CVE: CVE-2025-69202
Component: axios-cache-interceptor
CVSS v3: 4.7/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N
Release date: 2025-12-29T19:13:27.880000+00:00

Axios Cache Interceptor is a cache interceptor for axios. Prior to version 1.11.1, when a server calls an upstream service using different auth tokens, axios-cache-interceptor returns incorrect cached responses, leading to authorization bypass. The cache key is generated only from the URL, ignoring request headers like `Authorization`. When the server responds with `Vary: Authorization` (indicating the response varies by auth token), the library ignores this, causing all requests to share the same cache regardless of authorization. Server-side applications (APIs, proxies, backend services) that use axios-cache-interceptor to cache requests to upstream services, handle requests from multiple users with different auth tokens, and upstream services replies on `Vary` to differentiate caches are affected. Browser/client-side applications (single user per browser session) are not affected. Services using different auth tokens to call upstream services will return incorrect cached data, bypassing authorization checks and leaking user data across different authenticated sessions. After `v1.11.1`, automatic `Vary` header support is now enabled by default. When server responds with `Vary: Authorization`, cache keys now include the authorization header value. Each user gets their own cache.

Statement: Red Hat Product Security has determined that this vulnerability does not affect any currently supported Red Hat product. This assessment may evolve based on further analysis and discovery. For more information about this vulnerability and the products it affects, please see the linked references.

Remediation:
CVE: CVE-2025-6810
Component: Mescius ActiveReports.NET ReadValue Deserialization of Untrusted Data Remote Code Execution Vulnerability
Release date: 2025-06-27T22:40:50.293000+00:00

Mescius ActiveReports.NET ReadValue Deserialization of Untrusted Data Remote Code Execution Vulnerability. This vulnerability allows remote attackers to execute arbitrary code on affected installations of Mescius ActiveReports.NET. Interaction with this library is required to exploit this vulnerability but attack vectors may vary depending on the implementation.

The specific flaw exists within the implementation of the ReadValue method. The issue results from the lack of proper validation of user-supplied data, which can result in deserialization of untrusted data. An attacker can leverage this vulnerability to execute code in the context of the current process. Was ZDI-CAN-25246.

Statement: Red Hat Product Security has determined that this vulnerability does not affect any currently supported Red Hat product. This assessment may evolve based on further analysis and discovery. For more information about this vulnerability and the products it affects, please see the linked references.

Remediation:
Gitea: Unauthorized branch deletion due to inadequate permission enforcement
CVE: CVE-2025-68940
Component: gitea
CWE: CWE-863
Severity: Low
CVSS v3: 3.2/AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:N
Release date: 2025-12-26T02:14:52.076000+00:00

In Gitea before 1.22.5, branch deletion permissions are not adequately enforced after merging a pull request.

Statement: This vulnerability is rated Low for Red Hat OpenShift Pipelines. The flaw in Gitea, integrated with OpenShift Pipelines, allows a low-privileged attacker to delete branches without proper authorization after a pull request is merged. This could compromise the integrity and history of affected repositories.

Remediation:
Mitigation for this issue is either not available or the currently available options do not meet the Red Hat Product Security criteria comprising ease of use and deployment, applicability to widespread installation base, or stability.
abort in readelf via crafted ELF binary with malformed DWARF abbrev or debug information
CVE: CVE-2025-69652
Component: binutils
CWE: CWE-617
Severity: Low
CVSS v3: 3.2/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L
Release date: 2025-01-01T00:00:00+00:00

A flaw was found in binutils. Processing a specially crafted ELF binary file containing malformed DWARF abbrev or debug information with the readelf program using the -w abbrev command line option can trigger an abort, causing a crash and resulting in a denial of service.

Statement: This issue is classified with a low severity primarily because binutils is not typically exposed to untrusted inputs in most environments, limiting the possibility of exploitation. Additionally, this reachable abort is only triggered during the parsing of a specially crafted file, requiring an attacker to convince a user to process this file with readelf. Furthermore, binutils does not handle privileged operations, meaning that exploitation is unlikely to lead to system compromise or escalation of privileges. Also, the impact is limited to the application itself, without affecting the broader system or network security.

Remediation:
To mitigate this vulnerability, do not process untrusted, unverified or externally supplied ELF binaries with the readelf program.
csvtojson prototype pollution
CVE: CVE-2025-57350
Component: csvtojson
CWE: CWE-1321
Severity: Moderate
CVSS v3: 4.9/AV:L/AC:L/PR:H/UI:N/S:U/C:L/I:L/A:L
Release date: 2025-09-24T00:00:00+00:00

A prototype pollution flaw has been discovered in the csvtojson npm module. When processing CSV input containing specially crafted header fields that reference prototype chains (e.g., using __proto__ syntax), the application may unintentionally modify properties of the base Object prototype. This vulnerability can lead to denial of service conditions or unexpected behavior in applications relying on unmodified prototype chains, particularly when untrusted CSV data is processed.


Remediation:
Mitigation for this issue is either not available or the currently available options do not meet the Red Hat Product Security criteria comprising ease of use and deployment, applicability to widespread installation base or stability.
drm/v3d: Add job to pending list if the reset was skipped
CVE: CVE-2025-37951
Component: kernel
Severity: None
Release date: 2025-05-20T00:00:00+00:00

In the Linux kernel, the following vulnerability has been resolved:

drm/v3d: Add job to pending list if the reset was skipped

When a CL/CSD job times out, we check if the GPU has made any progress
since the last timeout. If so, instead of resetting the hardware, we skip
the reset and let the timer get rearmed. This gives long-running jobs a
chance to complete.

However, when `timedout_job()` is called, the job in question is removed
from the pending list, which means it won't be automatically freed through
`free_job()`. Consequently, when we skip the reset and keep the job
running, the job won't be freed when it finally completes.

This situation leads to a memory leak, as exposed in [1] and [2].

Similarly to commit 704d3d60fec4 ("drm/etnaviv: don't block scheduler when
GPU is still active"), this patch ensures the job is put back on the
pending list when extending the timeout.


Remediation: