AlmaLinux 9.2 [TuxCare] Security Update: openexr / openexr-devel / openexr-libs Multiple Vulnerabilities (ALMALINUX9.2:CLSA-2026:1792627161)

#%NASL_MIN_LEVEL 80900
##
# (C) Tenable, Inc.
##

include('compat.inc');

if (description)
{
  script_id(370232);
  script_version("1.1");
  script_set_attribute(attribute:"plugin_modification_date", value:"2026/10/22");

  script_cve_id(
    "CVE-2026-54920",
    "CVE-2026-55059",
    "CVE-2026-55373",
    "CVE-2026-59183",
    "CVE-2026-59184",
    "CVE-2026-59186",
    "CVE-2026-59189",
    "CVE-2026-59981",
    "CVE-2026-59983",
    "CVE-2026-59984",
    "CVE-2026-61555"
  );
  script_xref(name:"CLSA", value:"2026:1792627161");

  script_name(english:"AlmaLinux 9.2 [TuxCare] Security Update: openexr / openexr-devel / openexr-libs Multiple Vulnerabilities (ALMALINUX9.2:CLSA-2026:1792627161)");

  script_set_attribute(attribute:"synopsis", value:
"The AlmaLinux host is missing one or more security updates.");
  script_set_attribute(attribute:"description", value:
"The AlmaLinux 9.2 host has packages installed that are affected by multiple vulnerabilities as referenced in the TuxCare
ALMALINUX9.2:CLSA-2026:1792627161 advisory.

  - OpenEXR is the reference implementation and specification for the EXR image format, widely used in the
    motion picture industry. In versions 3.4.0 through 3.4.12, a reachable assertion failure in the HTJ2K
    decode path allows a crafted HTJ2K-compressed EXR file to cause an unconditional process abort in any
    application that calls exr_start_read() on untrusted input, resulting in denial of service. The crash is
    triggered by a QCD marker whose lower five bits are zero, which OpenEXR passes into the vendored OpenJPH
    library while constructing the codestream and evaluating its quantization delta parameters. OpenJPH uses
    an assertion rather than a recoverable error to validate those bits, so any invalid value calls abort()
    directly and cannot be intercepted by surrounding error handling, a problem compounded by OpenEXR wrapping
    only its internal HT header parser in error handling while leaving the later codestream read and
    construction calls unprotected. This issue has been resolved in version 3.4.13. (CVE-2026-54920)

  - OpenEXR is the reference implementation and specification for the EXR image format, widely used in the
    motion picture industry. Versions prior to 3.2.10, 3.3.12 and 3.4.13 contain a heap out-of-bounds write in
    Imf_4_0::SampleCountChannel::set(int r, unsigned int newNumSamples[]). The row-based sample-count setter
    computes the target Y coordinate with dataWindow.min.x instead of dataWindow.min.y. For a valid deep image
    data window where min.x != min.y, a valid row index can be translated into an invalid Y coordinate,
    causing writes before the allocated _numSamples buffer. The vulnerability is reachable through the public
    OpenEXRUtil DeepImage API and can lead to heap corruption and process crashes. This issue has been fixed
    in versions 3.2.10, 3.3.12 and 3.4.13. (CVE-2026-55059)

  - OpenEXR is the reference implementation and specification for the EXR image format, widely used in the
    motion picture industry. Versions prior to 3.2.10, 3.3.12, and 3.4.13 contain an infinite-loop
    vulnerability in SampleCountChannel. The helper roundListSizeUp() rounds a sample-list size up to the next
    power of two using repeated unsigned left shifts, which terminates for normal values but fails for
    UINT_MAX: the sequence reaches 0x80000000, and the next left shift wraps the 32-bit value to 0. Because 0
    remains less than UINT_MAX, the loop never progresses and never exits. The bug is reachable through public
    OpenEXRUtil APIs, either by editing the sample-count buffer through SampleCountChannel::Edit (whose
    destructor calls endEdit()) or by calling SampleCountChannel::set(x, y, UINT_MAX) on a valid pixel. This
    issue has been fixed in versions 3.2.10, 3.3.12, and 3.4.13. (CVE-2026-55373)

  - OpenEXR is the reference implementation and specification for the EXR image format, widely used in the
    motion picture industry. In versions 3.1.0 through 3.2.10, 3.3.0 through 3.3.12, and 3.4.0 through 3.4.13,
    an int32_t multiplication in OpenEXRCore's unpack_sample_table() can overflow while decoding a crafted
    deep tiled EXR file, producing an invalid pointer that leads to a read from an unmapped memory address and
    a crash. Because the overflow occurs in the standard decoding path (exr_decoding_run), any application
    that decodes deep tiled EXR files is affected. This issue is fixed in versions 3.2.11, 3.3.13, and 3.4.14.
    (CVE-2026-59183)

  - OpenEXR is the reference implementation and specification for the EXR image format, widely used in the
    motion picture industry. Versions before 3.2.11, 3.3.0 through 3.3.12, and 3.4.0 through 3.4.13 allow a
    crafted EXR with a nonzero dataWindow.min to make TypedFlatImageChannel::row() return an invalid heap
    pointer, causing out-of-bounds or use-after-free writes. This occurs when an application writes rows
    through FlatHalfChannel::row(). Affected consumers are tools, converters, render pipeline components, or
    image-processing services that accept untrusted EXR files and use FlatHalfChannel::row() on loaded images.
    This issue is fixed in versions 3.2.11, 3.3.13, and 3.4.14. (CVE-2026-59184)

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version
number.");
  # https://security.tuxcare.com/csaf/v2/els_os/almalinux9.2esu/advisories/2026/clsa-2026_1792627161.json
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?9342db17");
  script_set_attribute(attribute:"see_also", value:"https://cve.tuxcare.com/els/releases/CLSA-2026:1792627161");
  script_set_attribute(attribute:"solution", value:
"Update the affected packages based on the guidance in TuxCare advisory ALMALINUX9.2:CLSA-2026:1792627161.");
  script_set_cvss_base_vector("CVSS2#AV:N/AC:L/Au:N/C:P/I:N/A:C");
  script_set_cvss_temporal_vector("CVSS2#E:U/RL:OF/RC:C");
  script_set_cvss3_base_vector("CVSS:3.0/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H");
  script_set_cvss3_temporal_vector("CVSS:3.0/E:U/RL:O/RC:C");
  script_set_attribute(attribute:"cvss_score_source", value:"CVE-2026-59981");

  script_set_attribute(attribute:"exploitability_ease", value:"No known exploits are available");
  script_set_attribute(attribute:"exploit_available", value:"false");
  script_set_attribute(attribute:"vendor_severity", value:"Critical");

  script_set_attribute(attribute:"vuln_publication_date", value:"2026/08/14");
  script_set_attribute(attribute:"patch_publication_date", value:"2026/10/22");
  script_set_attribute(attribute:"plugin_publication_date", value:"2026/10/22");

  script_set_attribute(attribute:"plugin_type", value:"local");
  script_set_attribute(attribute:"generated_plugin", value:"current");
  script_end_attributes();

  script_category(ACT_GATHER_INFO);
  script_family(english:"Alma Linux Local Security Checks");

  script_copyright(english:"This script is Copyright (C) 2026 and is owned by Tenable, Inc. or an Affiliate thereof.");

  script_dependencies("ssh_get_info2.nasl");
  script_require_keys("Host/OS/extended-third-party", "Host/local_checks_enabled", "Host/AlmaLinux/release", "Host/AlmaLinux/rpm-list", "Host/cpu");

  exit(0);
}
include('rpm2.inc');

var third_party_support = get_kb_item('Host/OS/extended-third-party');
if (empty_or_null(third_party_support) || third_party_support != 'TuxCare') exit(0, 'TuxCare support not enabled.');

if (!get_kb_item('Host/local_checks_enabled')) audit(AUDIT_LOCAL_CHECKS_NOT_ENABLED);
var os_product = get_kb_item('installed_os/local/SSH/0/product');
if (isnull(os_product) || 'AlmaLinux' >!< os_product) audit(AUDIT_OS_NOT, 'AlmaLinux');
var os_version = get_kb_item('installed_os/local/SSH/0/version');
if (isnull(os_version)) audit(AUDIT_UNKNOWN_APP_VER, 'AlmaLinux');
if (! preg(pattern:"^9.2([^0-9]|$)", string:os_version)) audit(AUDIT_OS_NOT, 'AlmaLinux 9.2', 'AlmaLinux ' + os_version);

if (!get_kb_item('Host/AlmaLinux/rpm-list')) audit(AUDIT_PACKAGE_LIST_MISSING);

var cpu = get_kb_item('Host/cpu');
if (isnull(cpu)) audit(AUDIT_UNKNOWN_ARCH);
if ('aarch64' >!< cpu && cpu !~ "^i[3-6]86$" && 'x86_64' >!< cpu) audit(AUDIT_LOCAL_CHECKS_NOT_IMPLEMENTED, 'AlmaLinux', cpu);


var constraints = [
  {
    'release': '9',
    'sp': '2',
    'pkgs': [
      {'reference':'openexr-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'aarch64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'openexr-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'i686', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'openexr-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'x86_64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'openexr-devel-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'aarch64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'openexr-devel-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'i686', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'openexr-devel-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'x86_64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'openexr-libs-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'aarch64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'openexr-libs-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'i686', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'openexr-libs-3.1.1-3.el9.tuxcare.els11', 'sp':'2', 'cpu':'x86_64', 'rpm_spec_vers_cmp':TRUE}
    ]
  }
];

var os_release = get_one_kb_item('installed_os/local/SSH/0/release');
var os_sp = get_one_kb_item('Host/*/minor_release');

var flag = 0;
var reference;
var sp;
var _cpu;
var el_string;
var rpm_spec_vers_cmp;
var epoch;
var allowmaj;
var exists_check;
var cves;
foreach var constraint ( constraints ) {
  # Check that the target release is equal to the affected release
  if (!empty_or_null(constraint['release'])){
    if (constraint['release'] != os_release) continue;
  }
  if (!empty_or_null(constraint['sp'])){
    if (constraint['sp'] != os_sp) continue;
  }
  foreach var pkg ( constraint['pkgs'] ) {
    reference = NULL;
    sp = NULL;
    _cpu = NULL;
    el_string = NULL;
    rpm_spec_vers_cmp = NULL;
    epoch = NULL;
    allowmaj = NULL;
    exists_check = NULL;
    cves = NULL;
    if (!empty_or_null(pkg['reference'])) reference = pkg['reference'];
    if (!empty_or_null(pkg['sp'])) sp = pkg['sp'];
    if (!empty_or_null(pkg['cpu'])) _cpu = pkg['cpu'];
    if (!empty_or_null(pkg['el_string'])) el_string = pkg['el_string'];
    if (!empty_or_null(pkg['rpm_spec_vers_cmp'])) rpm_spec_vers_cmp = pkg['rpm_spec_vers_cmp'];
    if (!empty_or_null(pkg['epoch'])) epoch = pkg['epoch'];
    if (!empty_or_null(pkg['allowmaj'])) allowmaj = pkg['allowmaj'];
    if (!empty_or_null(pkg['exists_check'])) exists_check = pkg['exists_check'];
    if (!empty_or_null(pkg['cves'])) cves = pkg['cves'];
    if (reference &&
        ## (no known rpm to check OR known rpm_exists)
        (!exists_check || rpm_exists(rpm:exists_check)) &&
        rpm_check(sp:sp, cpu:_cpu, reference:reference, epoch:epoch, el_string:el_string, rpm_spec_vers_cmp:rpm_spec_vers_cmp, allowmaj:allowmaj, cves:cves)) flag++;
  }
}


if (flag)
{
  security_report_v4(
      port       : 0,
      severity   : SECURITY_HOLE,
      extra      : rpm_report_get()
  );
  exit(0);
}
else
{
  var tested = pkg_tests_get();
  if (tested) audit(AUDIT_PACKAGE_NOT_AFFECTED, tested);
  else audit(AUDIT_PACKAGE_NOT_INSTALLED, 'openexr / openexr-devel / openexr-libs');
}