<?xml version='1.0' encoding='UTF-8'?>
<?xml-stylesheet href="/static/style.xsl" type="text/xsl"?>
<rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" version="2.0">
  <channel>
    <title>Most recent entries from all</title>
    <link>https://cve.radiocsirt.org</link>
    <description>Contains only the most 10 recent entries.</description>
    <docs>http://www.rssboard.org/rss-specification</docs>
    <generator>python-feedgen</generator>
    <language>en</language>
    <lastBuildDate>Mon, 12 Oct 2026 15:37:14 +0000</lastBuildDate>
    <item>
      <title>certfr-2026-avi-0281 — De multiples vulnérabilités ont été découvertes dans les produits Splunk. Certaines d'entre elles permettent à un attaq…</title>
      <link>https://cve.radiocsirt.org/vuln/certfr-2026-avi-0281</link>
      <description>certfr-2026-avi-0281</description>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/certfr-2026-avi-0281</guid>
    </item>
    <item>
      <title>cnvd-2025-24799</title>
      <link>https://cve.radiocsirt.org/vuln/cnvd-2025-24799</link>
      <description>cnvd-2025-24799</description>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/cnvd-2025-24799</guid>
    </item>
    <item>
      <title>EUVD-2026-248838</title>
      <link>https://cve.radiocsirt.org/vuln/euvd-2026-248838</link>
      <description>EUVD-2026-248838</description>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/euvd-2026-248838</guid>
    </item>
    <item>
      <title>fkie_cve-2025-48071</title>
      <link>https://cve.radiocsirt.org/vuln/fkie_cve-2025-48071</link>
      <description>&lt;p&gt;OpenEXR provides the specification and reference implementation of the EXR file format, an image storage format for the motion picture industry. In versions 3.3.2 through 3.3.0, there is a heap-based buffer overflow during a write operation when decompressing ZIPS-packed deep scan-line EXR files with a maliciously forged chunk header. This is fixed in version 3.3.3.&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;OpenEXR provides the specification and reference implementation of the EXR file format, an image storage format for the motion picture industry. In versions 3.3.2 through 3.3.0, there is a heap-based buffer overflow during a write operation when decompressing ZIPS-packed deep scan-line EXR files with a maliciously forged chunk header. This is fixed in version 3.3.3.&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/fkie_cve-2025-48071</guid>
    </item>
    <item>
      <title>GHSA-h45x-qhg2-q375 — OpenEXR Heap-Based Buffer Overflow in Deep Scanline Parsing via Forged Unpacked Size</title>
      <link>https://cve.radiocsirt.org/vuln/ghsa-h45x-qhg2-q375</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; PyPI: OpenEXR&lt;/p&gt;
&lt;p&gt;### Summary&lt;/p&gt;
&lt;p&gt;The OpenEXRCore code is vulnerable to a heap-based buffer overflow during a write operation when decompressing ZIPS-packed deep scan-line EXR files with a maliciously forged chunk header.&lt;/p&gt;
&lt;p&gt;### Details
When parsing `STORAGE_DEEP_SCANLINE` chunks from an EXR file, the following code (from `src/lib/OpenEXRCore/chunk.c`) is used to extract the chunk information:&lt;/p&gt;
&lt;p&gt;```cpp&lt;/p&gt;
&lt;p&gt;if (part-&amp;gt;storage_mode == EXR_STORAGE_DEEP_SCANLINE)
// SNIP...
        cinfo-&amp;gt;sample_count_data_offset = dataoff;
        cinfo-&amp;gt;sample_count_table_size  = (uint64_t) ddata[0];
        cinfo-&amp;gt;data_offset              = dataoff + (uint64_t) ddata[0];
        cinfo-&amp;gt;packed_size              = (uint64_t) ddata[1];
        cinfo-&amp;gt;unpacked_size            = (uint64_t) ddata[2];
// SNIP...
```&lt;/p&gt;
&lt;p&gt;By storing this information, the code that will later decompress and reconstruct the chunk bytes, will know how much space the uncompressed data will occupy.&lt;/p&gt;
&lt;p&gt;This size is carried along in the chain of decoding/decompression until the `undo_zip_impl` function in `src/lib/OpenEXRCore/internal_zip.c`:&lt;/p&gt;
&lt;p&gt;```cpp
static exr_result_t
undo_zip_impl (
    exr_decode_pipeline_t* decode,
    const void*            compressed_data,
    uint64_t               comp_buf_size,
    void*                  uncompressed_data,
    uint64_t               uncompressed_size,
    void*                  scratch_data,
    uint64_t               scratch_size)
{
    size_t       actual_out_bytes;
    exr_result_t res;&lt;/p&gt;
&lt;p&gt;if (scratch_size &amp;lt;…&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; PyPI: OpenEXR&lt;/p&gt;
&lt;p&gt;### Summary&lt;/p&gt;
&lt;p&gt;The OpenEXRCore code is vulnerable to a heap-based buffer overflow during a write operation when decompressing ZIPS-packed deep scan-line EXR files with a maliciously forged chunk header.&lt;/p&gt;
&lt;p&gt;### Details
When parsing `STORAGE_DEEP_SCANLINE` chunks from an EXR file, the following code (from `src/lib/OpenEXRCore/chunk.c`) is used to extract the chunk information:&lt;/p&gt;
&lt;p&gt;```cpp&lt;/p&gt;
&lt;p&gt;if (part-&amp;gt;storage_mode == EXR_STORAGE_DEEP_SCANLINE)
// SNIP...
        cinfo-&amp;gt;sample_count_data_offset = dataoff;
        cinfo-&amp;gt;sample_count_table_size  = (uint64_t) ddata[0];
        cinfo-&amp;gt;data_offset              = dataoff + (uint64_t) ddata[0];
        cinfo-&amp;gt;packed_size              = (uint64_t) ddata[1];
        cinfo-&amp;gt;unpacked_size            = (uint64_t) ddata[2];
// SNIP...
```&lt;/p&gt;
&lt;p&gt;By storing this information, the code that will later decompress and reconstruct the chunk bytes, will know how much space the uncompressed data will occupy.&lt;/p&gt;
&lt;p&gt;This size is carried along in the chain of decoding/decompression until the `undo_zip_impl` function in `src/lib/OpenEXRCore/internal_zip.c`:&lt;/p&gt;
&lt;p&gt;```cpp
static exr_result_t
undo_zip_impl (
    exr_decode_pipeline_t* decode,
    const void*            compressed_data,
    uint64_t               comp_buf_size,
    void*                  uncompressed_data,
    uint64_t               uncompressed_size,
    void*                  scratch_data,
    uint64_t               scratch_size)
{
    size_t       actual_out_bytes;
    exr_result_t res;&lt;/p&gt;
&lt;p&gt;if (scratch_size &amp;lt;…&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/ghsa-h45x-qhg2-q375</guid>
    </item>
    <item>
      <title>openSUSE-SU-2025:15415-1 — libIex-3_3-32-3.3.5-1.1 on GA media</title>
      <link>https://cve.radiocsirt.org/vuln/opensuse-su-2025:15415-1</link>
      <description>&lt;p&gt;libIex-3_3-32-3.3.5-1.1 on GA media&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;libIex-3_3-32-3.3.5-1.1 on GA media&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/opensuse-su-2025:15415-1</guid>
    </item>
    <item>
      <title>PYSEC-2026-1747 — OpenEXR Heap-Based Buffer Overflow in Deep Scanline Parsing via Forged Unpacked Size</title>
      <link>https://cve.radiocsirt.org/vuln/pysec-2026-1747</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; PyPI: openexr&lt;/p&gt;
&lt;p&gt;### Summary&lt;/p&gt;
&lt;p&gt;The OpenEXRCore code is vulnerable to a heap-based buffer overflow during a write operation when decompressing ZIPS-packed deep scan-line EXR files with a maliciously forged chunk header.&lt;/p&gt;
&lt;p&gt;### Details
When parsing `STORAGE_DEEP_SCANLINE` chunks from an EXR file, the following code (from `src/lib/OpenEXRCore/chunk.c`) is used to extract the chunk information:&lt;/p&gt;
&lt;p&gt;```cpp&lt;/p&gt;
&lt;p&gt;if (part-&amp;gt;storage_mode == EXR_STORAGE_DEEP_SCANLINE)
// SNIP...
        cinfo-&amp;gt;sample_count_data_offset = dataoff;
        cinfo-&amp;gt;sample_count_table_size  = (uint64_t) ddata[0];
        cinfo-&amp;gt;data_offset              = dataoff + (uint64_t) ddata[0];
        cinfo-&amp;gt;packed_size              = (uint64_t) ddata[1];
        cinfo-&amp;gt;unpacked_size            = (uint64_t) ddata[2];
// SNIP...
```&lt;/p&gt;
&lt;p&gt;By storing this information, the code that will later decompress and reconstruct the chunk bytes, will know how much space the uncompressed data will occupy.&lt;/p&gt;
&lt;p&gt;This size is carried along in the chain of decoding/decompression until the `undo_zip_impl` function in `src/lib/OpenEXRCore/internal_zip.c`:&lt;/p&gt;
&lt;p&gt;```cpp
static exr_result_t
undo_zip_impl (
    exr_decode_pipeline_t* decode,
    const void*            compressed_data,
    uint64_t               comp_buf_size,
    void*                  uncompressed_data,
    uint64_t               uncompressed_size,
    void*                  scratch_data,
    uint64_t               scratch_size)
{
    size_t       actual_out_bytes;
    exr_result_t res;&lt;/p&gt;
&lt;p&gt;if (scratch_size &amp;lt;…&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; PyPI: openexr&lt;/p&gt;
&lt;p&gt;### Summary&lt;/p&gt;
&lt;p&gt;The OpenEXRCore code is vulnerable to a heap-based buffer overflow during a write operation when decompressing ZIPS-packed deep scan-line EXR files with a maliciously forged chunk header.&lt;/p&gt;
&lt;p&gt;### Details
When parsing `STORAGE_DEEP_SCANLINE` chunks from an EXR file, the following code (from `src/lib/OpenEXRCore/chunk.c`) is used to extract the chunk information:&lt;/p&gt;
&lt;p&gt;```cpp&lt;/p&gt;
&lt;p&gt;if (part-&amp;gt;storage_mode == EXR_STORAGE_DEEP_SCANLINE)
// SNIP...
        cinfo-&amp;gt;sample_count_data_offset = dataoff;
        cinfo-&amp;gt;sample_count_table_size  = (uint64_t) ddata[0];
        cinfo-&amp;gt;data_offset              = dataoff + (uint64_t) ddata[0];
        cinfo-&amp;gt;packed_size              = (uint64_t) ddata[1];
        cinfo-&amp;gt;unpacked_size            = (uint64_t) ddata[2];
// SNIP...
```&lt;/p&gt;
&lt;p&gt;By storing this information, the code that will later decompress and reconstruct the chunk bytes, will know how much space the uncompressed data will occupy.&lt;/p&gt;
&lt;p&gt;This size is carried along in the chain of decoding/decompression until the `undo_zip_impl` function in `src/lib/OpenEXRCore/internal_zip.c`:&lt;/p&gt;
&lt;p&gt;```cpp
static exr_result_t
undo_zip_impl (
    exr_decode_pipeline_t* decode,
    const void*            compressed_data,
    uint64_t               comp_buf_size,
    void*                  uncompressed_data,
    uint64_t               uncompressed_size,
    void*                  scratch_data,
    uint64_t               scratch_size)
{
    size_t       actual_out_bytes;
    exr_result_t res;&lt;/p&gt;
&lt;p&gt;if (scratch_size &amp;lt;…&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/pysec-2026-1747</guid>
    </item>
    <item>
      <title>Withdrawn: UBUNTU-CVE-2025-48071</title>
      <link>https://cve.radiocsirt.org/vuln/ubuntu-cve-2025-48071</link>
      <description>&lt;p&gt;&lt;strong&gt;Withdrawn by the publisher.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Ubuntu:Pro:16.04:LTS: openexr, Ubuntu:18.04:LTS: openexr, Ubuntu:Pro:20.04:LTS: openexr, Ubuntu:Pro:22.04:LTS: openexr, Ubuntu:24.04:LTS: openexr, Ubuntu:25.10: openexr&lt;/p&gt;
&lt;p&gt;OpenEXR provides the specification and reference implementation of the EXR file format, an image storage format for the motion picture industry. In versions 3.3.2 through 3.3.0, there is a heap-based buffer overflow during a write operation when decompressing ZIPS-packed deep scan-line EXR files with a maliciously forged chunk header. This is fixed in version 3.3.3.&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Withdrawn by the publisher.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Ubuntu:Pro:16.04:LTS: openexr, Ubuntu:18.04:LTS: openexr, Ubuntu:Pro:20.04:LTS: openexr, Ubuntu:Pro:22.04:LTS: openexr, Ubuntu:24.04:LTS: openexr, Ubuntu:25.10: openexr&lt;/p&gt;
&lt;p&gt;OpenEXR provides the specification and reference implementation of the EXR file format, an image storage format for the motion picture industry. In versions 3.3.2 through 3.3.0, there is a heap-based buffer overflow during a write operation when decompressing ZIPS-packed deep scan-line EXR files with a maliciously forged chunk header. This is fixed in version 3.3.3.&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/ubuntu-cve-2025-48071</guid>
    </item>
  </channel>
</rss>
