huzaifas-sidhpurwala/RedHat-security-VeX huggingface dataset:
crypto: ccp - Fix crash when rebind ccp device for ccp.ko
CVE: CVE-2025-38581
Component: kernel
CWE: CWE-476
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-08-19T00:00:00+00:00

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

crypto: ccp - Fix crash when rebind ccp device for ccp.ko

When CONFIG_CRYPTO_DEV_CCP_DEBUGFS is enabled, rebinding
the ccp device causes the following crash:

$ echo '0000:0a:00.2' > /sys/bus/pci/drivers/ccp/unbind
$ echo '0000:0a:00.2' > /sys/bus/pci/drivers/ccp/bind

[  204.976930] BUG: kernel NULL pointer dereference, address: 0000000000000098
[  204.978026] #PF: supervisor write access in kernel mode
[  204.979126] #PF: error_code(0x0002) - not-present page
[  204.980226] PGD 0 P4D 0
[  204.981317] Oops: Oops: 0002 [#1] SMP NOPTI
...
[  204.997852] Call Trace:
[  204.999074]  <TASK>
[  205.000297]  start_creating+0x9f/0x1c0
[  205.001533]  debugfs_create_dir+0x1f/0x170
[  205.002769]  ? srso_return_thunk+0x5/0x5f
[  205.004000]  ccp5_debugfs_setup+0x87/0x170 [ccp]
[  205.005241]  ccp5_init+0x8b2/0x960 [ccp]
[  205.006469]  ccp_dev_init+0xd4/0x150 [ccp]
[  205.007709]  sp_init+0x5f/0x80 [ccp]
[  205.008942]  sp_pci_probe+0x283/0x2e0 [ccp]
[  205.010165]  ? srso_return_thunk+0x5/0x5f
[  205.011376]  local_pci_probe+0x4f/0xb0
[  205.012584]  pci_device_probe+0xdb/0x230
[  205.013810]  really_probe+0xed/0x380
[  205.015024]  __driver_probe_device+0x7e/0x160
[  205.016240]  device_driver_attach+0x2f/0x60
[  205.017457]  bind_store+0x7c/0xb0
[  205.018663]  drv_attr_store+0x28/0x40
[  205.019868]  sysfs_kf_write+0x5f/0x70
[  205.021065]  kernfs_fop_write_iter+0x145/0x1d0
[  205.022267]  vfs_write+0x308/0x440
[  205.023453]  ksys_write+0x6d/0xe0
[  205.024616]  __x64_sys_write+0x1e/0x30
[  205.025778]  x64_sys_call+0x16ba/0x2150
[  205.026942]  do_syscall_64+0x56/0x1e0
[  205.028108]  entry_SYSCALL_64_after_hwframe+0x76/0x7e
[  205.029276] RIP: 0033:0x7fbc36f10104
[  205.030420] Code: 89 02 48 c7 c0 ff ff ff ff c3 66 2e 0f 1f 84 00 00 00 00 00 66 90 48 8d 05 e1 08 2e 00 8b 00 85 c0 75 13 b8 01 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 54 f3 c3 66 90 41 54 55 49 89 d4 53 48 89 f5

This patch sets ccp_debugfs_dir to NULL after destroying it in
ccp5_debugfs_destroy, allowing the directory dentry to be
recreated when rebinding the ccp device.

Tested on AMD Ryzen 7 1700X.


Remediation:
NVIDIA Container Toolkit Link Following Vulnerability
CVE: CVE-2025-23267
Component: nvidia-container-toolkit
CWE: CWE-59
Severity: Important
CVSS v3: 8.2/AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:H
Release date: 2025-07-17T19:32:36.958000+00:00

A flaw was found in nvidia-container-toolkit. The `update-ldcache` hook contains a vulnerability allowing an attacker to trigger link following via a specially crafted container image. This issue allows a local attacker to potentially cause data corruption. The root cause is the improper handling of container image paths during the link cache update process, which may result in data loss.

Statement: RHEL AI is not affected because it uses CDI mode with NVIDIA Container Toolkit versions later than 1.17.5, which are not vulnerable, and does not rely on the enable-cuda-compat hook, thereby eliminating the attack vector entirely.

This vulnerability is rated  as Important instead of Critical because, while it involves a symlink attack via the update-ldcache hook in the NVIDIA Container Toolkit, it has limited impact and specific requirements. The attacker needs low privileges inside a container and must use a specially crafted image to trigger the issue. It does not lead to code execution or privilege escalation, and it has no impact on confidentiality—only potential data tampering or denial of service. Additionally, the vulnerability affects only setups using this specific hook and can be easily mitigated by disabling it.

Remediation:
This vulnerability can be mitigated by opting out using the enable-cuda-compat hook. When using the NVIDIA Container Runtime in legacy mode, you can opt out of using the enable-cuda-compat hook by editing the /etc/nvidia-container-toolkit/config.toml file to set the features.disable-cuda-compat-lib-hook feature flag to true:

[features]
disable-cuda-compat-lib-hook = true
pillow: Pillow DDS Heap Buffer Overflow
CVE: CVE-2025-48379
Component: python-pillow
CWE: CWE-122
Severity: Important
CVSS v3: 7.2/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H
Release date: 2025-07-01T18:33:30.687000+00:00

A critical vulnerability was identified in the Pillow image processing library. This flaw could allow a local attacker to execute arbitrary code or cause the application to crash, resulting in a denial of service. An attacker can exploit this vulnerability by tricking an application into processing a specially crafted image file. The issue occurs because the library writes more data than an allocated memory buffer can hold, leading to memory corruption.

Statement: This vulnerability was rated as Important by the Red Hat Product Security Engineer. An attacker may leverage that by crafting a malicious DDS image bigger than 64k (when encoded). This happens because of the lack of size checking when writing the image data into an internal buffer. When successfully exploited, this vulnerability may lead to a local arbitrary code execution within the user privileges similar to the ones for the user running the application or a denial of service for the application consuming the Pillow library.

Remediation:
For more information visit https://access.redhat.com/errata/RHSA-2025:15839
For more information visit https://access.redhat.com/errata/RHSA-2025:15838
For more information visit https://access.redhat.com/errata/RHSA-2025:15840
For more information visit https://access.redhat.com/errata/RHSA-2025:15842
For more information visit https://access.redhat.com/errata/RHSA-2025:15837
For more information visit https://access.redhat.com/errata/RHSA-2025:15836
For more information visit https://access.redhat.com/errata/RHSA-2025:15841
For more information visit https://access.redhat.com/errata/RHSA-2025:15843
For more information visit https://access.redhat.com/errata/RHSA-2025:15867
For more information visit https://access.redhat.com/errata/RHSA-2025:15832
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.
bpf: Sync pending IRQ work before freeing ring buffer
CVE: CVE-2025-40319
Component: kernel
CWE: CWE-825
Severity: Moderate
CVSS v3: 6.0/AV:L/AC:H/PR:H/UI:N/S:U/C:N/I:H/A:H
Release date: 2025-12-08T00:00:00+00:00

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

bpf: Sync pending IRQ work before freeing ring buffer

Fix a race where irq_work can be queued in bpf_ringbuf_commit()
but the ring buffer is freed before the work executes.
In the syzbot reproducer, a BPF program attached to sched_switch
triggers bpf_ringbuf_commit(), queuing an irq_work. If the ring buffer
is freed before this work executes, the irq_work thread may accesses
freed memory.
Calling `irq_work_sync(&rb->work)` ensures that all pending irq_work
complete before freeing the buffer.


Remediation:
Portworx Half-Blind SSRF in kube-controller-manager
CVE: CVE-2025-13281
Component: kube-controller-manager
CWE: CWE-918
Severity: Moderate
CVSS v3: 5.1/AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:N/A:N
Release date: 2025-12-14T21:27:34.786000+00:00

A half-blind Server-Side Request Forgery (SSRF) found in kube-controller-manager that can be triggered when using the legacy in-tree Portworx StorageClass. An authorized user with sufficient privileges can cause the controller to make requests to internal, host-network–accessible endpoints, potentially leaking sensitive information from unprotected services.

Statement: This issue is classified as a Moderate vulnerability rather than an Important flaw because its exploitability and impact are significantly constrained by design and configuration prerequisites. Exploitation requires pre-existing high privileges, as the attacker must already be authorized to create pods using the legacy in-tree Portworx StorageClass, which is typically restricted in production clusters. The SSRF is half-blind, limiting the attacker’s ability to reliably control requests or exfiltrate data, and it only becomes meaningful when unprotected endpoints are exposed on the control plane host network, a condition that does not exist in properly hardened environments. There is no direct integrity or availability impact, no privilege escalation, and no code execution path. Additionally, the affected component is disabled by default in supported Kubernetes versions, further reducing real-world exposure. These technical constraints and dependency on non-default or misconfigured setups justify a moderate severity assessment rather than classification as an important flaw.

Remediation:
No mitigation is currently available that meets Red Hat Product Security’s standards for usability, deployment, applicability, or stability.
Segmentation fault when parsing malformed data URI
CVE: CVE-2025-32051
Component: libsoup
CWE: CWE-754
Severity: Moderate
CVSS v3: 5.8/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
Release date: 2025-04-03T00:00:00+00:00

A flaw was found in libsoup. The libsoup soup_uri_decode_data_uri() function may crash when processing malformed data URI. This flaw allows an attacker to cause a denial of service (DoS).


Remediation:
No mitigation is currently available for this vulnerability.
Type confusion in Entr'ouvert Lasso
CVE: CVE-2025-47151
Component: lasso
CWE: CWE-843
Severity: Critical
CVSS v3: 9.8/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Release date: 2025-11-05T14:57:01.436000+00:00

A type confusion vulnerability exists in the lasso_node_impl_init_from_xml functionality of Entr'ouvert Lasso 2.8.2 and prior. A specially crafted SAML response can lead to an arbitrary code execution. An attacker can send a malformed SAML response to trigger this vulnerability.


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.
Type Confusion in exsltFuncResultCompfunction of libxslt
CVE: CVE-2025-11731
Component: libxslt
CWE: CWE-843
Severity: Low
CVSS v3: 3.0/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:N/A:L
Release date: 2025-10-14T00:00:00+00:00

A flaw was found in the exsltFuncResultComp() function of libxslt, which handles EXSLT <func:result> elements during stylesheet parsing. Due to improper type handling, the function may treat an XML document node as a regular XML element node, resulting in a type confusion. This can cause unexpected memory reads and potential crashes. While difficult to exploit, the flaw could lead to application instability or denial of service.

Statement: The Red Hat Product Security team has rated this vulnerability as Low severity, given that exploitation only causes a crash and requires the processing of a specially crafted XSL stylesheet. There is no evidence of data corruption or code execution, but affected applications may experience denial-of-service conditions.

Remediation:
Mitigation for this issue is either not available or the currently available options don’t meet the Red Hat Product Security criteria comprising ease of use, applicability to a widespread installation base, or stability.
CVE: CVE-2025-14499
Component: IceWarp gmaps Cross-Site Scripting Authentication Bypass Vulnerability
Release date: 2025-12-11T00:02:24.445000+00:00

IceWarp gmaps Cross-Site Scripting Authentication Bypass Vulnerability. This vulnerability allows remote attackers to bypass authentication on affected installations of IceWarp. 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 handling of a parameter passed to the gmaps webpage. The issue results from the lack of proper validation of user-supplied data, which can lead to the injection of an arbitrary script. An attacker can leverage this vulnerability to bypass authentication on the system. Was ZDI-CAN-25441.

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:
staging: gpib: Fix Oops after disconnect in agilent usb
CVE: CVE-2025-22051
Component: kernel
CWE: CWE-476
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-04-16T00:00:00+00:00

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

staging: gpib: Fix Oops after disconnect in agilent usb

If the agilent usb dongle is disconnected subsequent calls to the
driver cause a NULL dereference Oops as the bus_interface
is set to NULL on disconnect.

This problem was introduced by setting usb_dev from the bus_interface
for dev_xxx messages.

Previously bus_interface was checked for NULL only in the functions
directly calling usb_fill_bulk_urb or usb_control_msg.

Check for valid bus_interface on all interface entry points
and return -ENODEV if it is NULL.


Remediation:
CVE: CVE-2025-15322
Component: Tanium addressed an improper access controls vulnerability in Tanium Server.
Release date: 2025-09-16T00:00:00+00:00

Tanium addressed an improper access controls vulnerability in Tanium Server.

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:
NFS: Fix LTP test failures when timestamps are delegated
CVE: CVE-2025-68242
Component: kernel
CWE: CWE-358
Severity: Moderate
CVSS v3: 4.5/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:L
Release date: 2025-12-16T00:00:00+00:00

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

NFS: Fix LTP test failures when timestamps are delegated

The utimes01 and utime06 tests fail when delegated timestamps are
enabled, specifically in subtests that modify the atime and mtime
fields using the 'nobody' user ID.

The problem can be reproduced as follow:

# echo "/media *(rw,no_root_squash,sync)" >> /etc/exports
# export -ra
# mount -o rw,nfsvers=4.2 127.0.0.1:/media /tmpdir
# cd /opt/ltp
# ./runltp -d /tmpdir -s utimes01
# ./runltp -d /tmpdir -s utime06

This issue occurs because nfs_setattr does not verify the inode's
UID against the caller's fsuid when delegated timestamps are
permitted for the inode.

This patch adds the UID check and if it does not match then the
request is sent to the server for permission checking.

Statement: This affects NFS 4.2 mounts with delegated timestamps enabled. The flaw allows timestamp modification bypass but does not permit reading or writing file contents, limiting the security impact.

Remediation:
CVE: CVE-2025-15288
Component: Tanium addressed an improper access controls vulnerability in Interact.
Release date: 2025-10-02T00:00:00+00:00

Tanium addressed an improper access controls vulnerability in Interact.

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:
Keras Model.load_model Arbitrary Local File Loading and SSRF
CVE: CVE-2025-12058
Component: keras
CWE: CWE-502
Severity: Moderate
CVSS v3: 5.3/AV:N/AC:H/PR:L/UI:R/S:C/C:L/I:L/A:L
Release date: 2025-10-29T08:48:29.689000+00:00

The Keras.Model.load_model method, including when executed with the intended security mitigation safe_mode=True, is vulnerable to arbitrary local file loading and Server-Side Request Forgery (SSRF).


This vulnerability stems from the way the StringLookup layer is handled during model loading from a specially crafted .keras archive. The constructor for the StringLookup layer accepts a vocabulary argument that can specify a local file path or a remote file path.

  *  Arbitrary Local File Read: An attacker can create a malicious .keras file that embeds a local path in the StringLookup layer's configuration. When the model is loaded, Keras will attempt to read the content of the specified local file and incorporate it into the model state (e.g., retrievable via get_vocabulary()), allowing an attacker to read arbitrary local files on the hosting system.


  *  Server-Side Request Forgery (SSRF): Keras utilizes tf.io.gfile for file operations. Since tf.io.gfile supports remote filesystem handlers (such as GCS and HDFS) and HTTP/HTTPS protocols, the same mechanism can be leveraged to fetch content from arbitrary network endpoints on the server's behalf, resulting in an SSRF condition.


The security issue is that the feature allowing external path loading was not properly restricted by the safe_mode=True flag, which was intended to prevent such unintended data access.


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.
Mbed TLS Use-After-Free Vulnerability
CVE: CVE-2025-47917
Component: mbedtls
CVSS v3: 8.8/AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:H/A:H
Release date: 2025-07-20T00:00:00+00:00

A flaw was found in mbedtls. The `mbedtls_x509_string_to_names()` function incorrectly documents a head argument as an output, leading to a use-after-free vulnerability when applications follow the provided documentation. This vulnerability allows a network-based attacker to trigger this condition, potentially resulting in a denial of service or information disclosure. This issue occurs due to improper handling of memory after it has been freed.

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:
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.
btrfs: don't clobber ret in btrfs_validate_super()
CVE: CVE-2025-22114
Component: kernel
Severity: None
Release date: 2025-04-16T00:00:00+00:00

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

btrfs: don't clobber ret in btrfs_validate_super()

Commit 2a9bb78cfd36 ("btrfs: validate system chunk array at
btrfs_validate_super()") introduces a call to validate_sys_chunk_array()
in btrfs_validate_super(), which clobbers the value of ret set earlier.
This has the effect of negating the validity checks done earlier, making
it so btrfs could potentially try to mount invalid filesystems.


Remediation:
React Server Components: Source code exposure through crafted HTTP request
CVE: CVE-2025-55183
Component: next
CWE: CWE-497
Severity: Moderate
CVSS v3: 5.3/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
Release date: 2025-12-11T20:04:48.655000+00:00

A flaw was found in React Server Components (RSC). This vulnerability allows an information leak, where a specifically crafted HTTP (Hypertext Transfer Protocol) request to a vulnerable Server Function can unsafely return its source code. Exploitation requires a Server Function that explicitly or implicitly exposes a stringified argument. A malicious HTTP request can be crafted and sent to any App Router endpoint that can return the compiled source code of Server Functions. This could reveal business logic, but would not expose secrets unless they were hardcoded directly into Server Function code.

Statement: ```

No Red Hat software includes the directly affected React Server Components packages (react-server-dom-parcel, react-server-dom-turbopack, react-server-dom-webpack). However, the reference implementation of React Server Components is used by other projects such as Next.js. The packages listed here include Next.js as a dependency, but our analysis indicates that they are not affected by the vulnerability as they do not use the App Router functionality that exposes endpoints serving the vulnerable protocol that can return the compiled source code of Server Functions.

```

Remediation:
Linux kernel: Deadlock due to MPTCP packet reinjection during fallback
CVE: CVE-2025-71126
Component: kernel
CWE: CWE-833
Severity: Moderate
CVSS v3: 5.1/AV:L/AC:L/PR:H/UI:N/S:U/C:N/I:N/A:H
Release date: 2025-01-01T00:00:00+00:00

A flaw was found in the Linux kernel's Multipath TCP (MPTCP) implementation. A remote attacker could exploit this vulnerability when the packet scheduler attempts to reinject packets after receiving an MP_FAIL message but before the infinite map has been fully transmitted. This timing issue can lead to a deadlock, causing a denial of service.

Statement: MPTCP is disabled by default in RHEL, and enabling it requires superuser permissions.

Remediation:
RDMA/siw: Fix the sendmsg byte count in siw_tcp_sendpages
CVE: CVE-2025-39758
Component: kernel
Severity: None
Release date: 2025-09-11T00:00:00+00:00

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

RDMA/siw: Fix the sendmsg byte count in siw_tcp_sendpages

Ever since commit c2ff29e99a76 ("siw: Inline do_tcp_sendpages()"),
we have been doing this:

static int siw_tcp_sendpages(struct socket *s, struct page **page, int offset,
                             size_t size)
[...]
        /* Calculate the number of bytes we need to push, for this page
         * specifically */
        size_t bytes = min_t(size_t, PAGE_SIZE - offset, size);
        /* If we can't splice it, then copy it in, as normal */
        if (!sendpage_ok(page[i]))
                msg.msg_flags &= ~MSG_SPLICE_PAGES;
        /* Set the bvec pointing to the page, with len $bytes */
        bvec_set_page(&bvec, page[i], bytes, offset);
        /* Set the iter to $size, aka the size of the whole sendpages (!!!) */
        iov_iter_bvec(&msg.msg_iter, ITER_SOURCE, &bvec, 1, size);
try_page_again:
        lock_sock(sk);
        /* Sendmsg with $size size (!!!) */
        rv = tcp_sendmsg_locked(sk, &msg, size);

This means we've been sending oversized iov_iters and tcp_sendmsg calls
for a while. This has a been a benign bug because sendpage_ok() always
returned true. With the recent slab allocator changes being slowly
introduced into next (that disallow sendpage on large kmalloc
allocations), we have recently hit out-of-bounds crashes, due to slight
differences in iov_iter behavior between the MSG_SPLICE_PAGES and
"regular" copy paths:

(MSG_SPLICE_PAGES)
skb_splice_from_iter
  iov_iter_extract_pages
    iov_iter_extract_bvec_pages
      uses i->nr_segs to correctly stop in its tracks before OoB'ing everywhere
  skb_splice_from_iter gets a "short" read

(!MSG_SPLICE_PAGES)
skb_copy_to_page_nocache copy=iov_iter_count
 [...]
   copy_from_iter
        /* this doesn't help */
        if (unlikely(iter->count < len))
                len = iter->count;
          iterate_bvec
            ... and we run off the bvecs

Fix this by properly setting the iov_iter's byte count, plus sending the
correct byte count to tcp_sendmsg_locked.


Remediation: