AlmaLinux 9.6 [TuxCare] Security Update: openssl / openssl-devel / openssl-libs / openssl-perl Multiple Vulnerabilities (ALMALINUX9.6:CLSA-2026:1789738618)

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

include('compat.inc');

if (description)
{
  script_id(351517);
  script_version("1.1");
  script_set_attribute(attribute:"plugin_modification_date", value:"2026/09/30");

  script_cve_id(
    "CVE-2026-14457",
    "CVE-2026-63074",
    "CVE-2026-63075",
    "CVE-2026-63076"
  );
  script_xref(name:"CLSA", value:"2026:1789738618");

  script_name(english:"AlmaLinux 9.6 [TuxCare] Security Update: openssl / openssl-devel / openssl-libs / openssl-perl Multiple Vulnerabilities (ALMALINUX9.6:CLSA-2026:1789738618)");

  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.6 host has packages installed that are affected by multiple vulnerabilities as referenced in the TuxCare
ALMALINUX9.6:CLSA-2026:1789738618 advisory.

  - Issue summary: In a server or client configuration with RFC7250 Raw Public Keys (RPKs) enabled, and only
    the private key (with no associated certificate) configured locally, a NULL pointer dereference may occur
    when the remote peer solicits raw public keys and also sends the typically omitted
    signature_algorithms_cert TLS extension. Impact summary: The impact is limited to a possible Denial of
    Service as a result of an application abort, no data disclosure or remote command execution are possible.
    CWE: CWE-476: NULL Pointer Dereference Description: While a passing comment in sample code in the
    documentation suggests that key-only RPK configurations are supported, the best-practice RPK configuration
    is to always configure a corresponding certificate (possibly self-signed or signed by any convenient CA).
    When the private key is configured along with a matching certificate, the signature_algorithms_cert
    extension is handled reliably even without the fix, and peer clients or servers that don't support raw
    public keys may be able to complete a TLS connection by pinning or verifying the corresponding certificate
    or its public key. Deployments that prefer to configure just a private key with no certificate need to
    upgrade to an updated release as noted below. FIPS impact: no No FIPS modules are affected by this issue,
    as the SSL protocol implementation is outside the OpenSSL FIPS module boundary. (CVE-2026-14457)

  - Issue summary: The OpenSSL Certificate Management Protocol (CMP) caches additional certificates
    (extraCerts) sent in a CMP message, but never expunges them (for instance if they are invalid). If a
    server reuses an OSSL_CMP_CTX frequently, this cache of extraCerts may grow unboundedly, and a malicious
    client may flood a CMP server with requests driving this growth. Impact summary: Users utilizing a CMP
    server that reuses a single OSSL_CMP_CTX for the lifetime of a server process may observe unbounded memory
    growth in the event a malicious client repeatedly sends requests containing unique extra certificates,
    which may lead to OOM conditions. CWE: CWE-770: Allocation of Resources Without Limits or Throttling
    Description: If a remote user sends CMP messages to a server with a list of extraCerts and the message is
    rejected, the extraCerts from the message remains in the server contexts untrusted certificate stack. This
    exposes servers with long lived ctx objects to Denial of Service attacks in which an attacker sends
    messages intending to be rejected with a large list of additional certificates repeatedly, forcing the
    server to store them indefinitely. The issue was fixed by removing the added extra certs if the message is
    rejected, using the same method as when the context is configured to not do caching at all. FIPS impact:
    no As the CMP code lives outside the FIPS module boundary, no FIPS modules are affected by this CVE.
    (CVE-2026-63074)

  - Issue summary: When OpenSSL processes QUIC traffic from a peer that repeatedly sends ack-eliciting packets
    while not acknowledging ACK-only responses, the QUIC stack can retain ACK-only packet metadata for the
    lifetime of the connection. Impact summary: A remote peer that can complete a QUIC handshake can cause
    connection-scoped memory growth which may lead to Denial of Service through memory exhaustion, especially
    with sustained traffic or many concurrent QUIC connections. CWE: CWE-770: Allocation of Resources Without
    Limits or Throttling Description: When the OpenSSL QUIC stack sends an ACK-only packet, there is no
    requirement by the QUIC protocol that the peer will acknowledge that ACK-only packet (i.e. it is itself
    not ack-eliciting). However, the OpenSSL implementation stores the metadata about the ACK frames
    regardless. In and of itself that's ok, but if a malicious peer establishes a connection, and then drives
    the connection such that ACK-only packets are forced from the OpenSSL implementation peer (i.e., by
    sending numerous PING frames), and then withholding any subsequent acks for ack-eliciting data, like
    legitimate data, said malicious peer can force inappropriate memory growth on the OpenSSL peer,
    potentially leading to a Denial of Service. The fix is to ensure that we account for the transmission of
    the ACK-only packet in the packet histories high and low watermark without actually storing the ACK-only
    packet metadata itself. FIPS impact: no The OpenSSL FIPS module is not affected as the QUIC code is
    outside the FIPS module boundary. (CVE-2026-63075)

  - Issue summary: OpenSSL CMP password based protection verification only checks whether the protectionAlg
    parameter was not NULL and not its ASN.1 type, before treating it as a PBMParameter. A crafted message can
    contain a parameter of a different type, which is then dereferenced as an invalid pointer. Impact summary:
    A remote, unauthenticated attacker can crash an application acting as a CMP server that accepts PBM-
    protected messages, or a CMP client talking to a malicious or intercepted CMP server, resulting in a
    Denial of Service. CWE: CWE-476: NULL Pointer Dereference Description: When verifying the password-based
    MAC protection of a CMP message, OpenSSL library reads the protectionAlg algorithm parameter with
    X509_ALGOR_get0(), which returns both the parameter type and its value pointer. The value is then cast to
    an ASN1_STRING and treated as the expected PBMParameter after only checking that pointer is not NULL. The
    parameter type returned by X509_ALGOR_get0() was never consulted. This happens during protection
    verification, before any MAC is computed, so no knowledge of the PBM shared secret is required; the only
    precondition is that PBM verification is reachable. On the server side this is reached from
    OSSL_CMP_SRV_process_request() for any application that stands up a CMP server accepting PBM-protected
    messages, and on the client side from CMP response validation against a malicious or on-path (MITM)
    server. The reliable consequence is a denial of service; there is no memory disclosure, no controlled
    memory write, and no path to code execution. CMP is a specialized feature that an application must
    explicitly enable. FIPS impact: no As the CMP code lives outside the FIPS module boundary, no FIPS modules
    are affected by this CVE. (CVE-2026-63076)

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/tuxcare9.6esu/advisories/2026/clsa-2026_1789738618.json
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?c7e89231");
  script_set_attribute(attribute:"see_also", value:"https://cve.tuxcare.com/els/releases/CLSA-2026:1789738618");
  script_set_attribute(attribute:"solution", value:
"Update the affected packages based on the guidance in TuxCare advisory ALMALINUX9.6:CLSA-2026:1789738618.");
  script_set_cvss_base_vector("CVSS2#AV:N/AC:L/Au:N/C:N/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:N/S:U/C:N/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-63076");

  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:"Important");

  script_set_attribute(attribute:"vuln_publication_date", value:"2026/08/05");
  script_set_attribute(attribute:"patch_publication_date", value:"2026/09/18");
  script_set_attribute(attribute:"plugin_publication_date", value:"2026/09/30");

  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.6([^0-9]|$)", string:os_version)) audit(AUDIT_OS_NOT, 'AlmaLinux 9.6', '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 (cpu !~ "^i[3-6]86$" && 'x86_64' >!< cpu) audit(AUDIT_LOCAL_CHECKS_NOT_IMPLEMENTED, 'AlmaLinux', cpu);


var constraints = [
  {
    'release': '9',
    'sp': '6',
    'pkgs': [
      {'reference':'openssl-3.2.2-7.el9_6.tuxcare.1.els12', 'sp':'6', 'cpu':'x86_64', 'el_string':'el9_6', 'rpm_spec_vers_cmp':TRUE, 'epoch':'1'},
      {'reference':'openssl-devel-3.2.2-7.el9_6.tuxcare.1.els12', 'sp':'6', 'cpu':'i686', 'el_string':'el9_6', 'rpm_spec_vers_cmp':TRUE, 'epoch':'1'},
      {'reference':'openssl-devel-3.2.2-7.el9_6.tuxcare.1.els12', 'sp':'6', 'cpu':'x86_64', 'el_string':'el9_6', 'rpm_spec_vers_cmp':TRUE, 'epoch':'1'},
      {'reference':'openssl-libs-3.2.2-7.el9_6.tuxcare.1.els12', 'sp':'6', 'cpu':'i686', 'el_string':'el9_6', 'rpm_spec_vers_cmp':TRUE, 'epoch':'1'},
      {'reference':'openssl-libs-3.2.2-7.el9_6.tuxcare.1.els12', 'sp':'6', 'cpu':'x86_64', 'el_string':'el9_6', 'rpm_spec_vers_cmp':TRUE, 'epoch':'1'},
      {'reference':'openssl-perl-3.2.2-7.el9_6.tuxcare.1.els12', 'sp':'6', 'cpu':'x86_64', 'el_string':'el9_6', 'rpm_spec_vers_cmp':TRUE, 'epoch':'1'}
    ]
  }
];

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, 'openssl / openssl-devel / openssl-libs / openssl-perl');
}