The remote SUSE Linux SLES15 / SLES_SAP15 host has packages installed that are affected by multiple vulnerabilities as referenced in the SUSE-SU-2026:2405-1 advisory.

    - CVE-2026-45447: Heap Use-After-Free in OpenSSL PKCS7_verify() (bsc#1266357).
    - CVE-2026-42766: Possible NULL Dereference in Password-Based CMS Decryption (bsc#1266349).
    - CVE-2026-9076:  Out-of-Bounds Read in CMS Password-Based Decryption (bsc#1266341).
    - CVE-2026-7383:  Possible Heap Buffer Overflow in ASN.1 Multibyte String Conversion (bsc#1266340).
    - CVE-2026-34180: Heap Buffer Over-read in ASN.1 Content Parsing (bsc#1266342).

Tenable has extracted the preceding description block directly from the SUSE security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

It is, therefore, affected by multiple vulnerabilities as referenced in the ALAS2-2026-3363 advisory.

    Issue summary: Parsing a crafted DER-encoded ASN.1 structure with a primitiveelement whose content exceeds     2 gigabytes in length may cause a heap bufferover-read on 64-bit Unix and Unix-like platforms.

    Impact summary: The heap buffer over-read may crash the application (Denial ofService) or to load into the     decoded ASN.1 object contents of memory beyond theend of the input buffer.  More typically such ASN.1     elements would instead betruncated.

    An integer truncation in OpenSSL's ASN.1 decoder causes the content length ofan ASN.1 primitive element to     be mishandled when it exceeds 2 gigabytes. In theworst case the truncated length is treated as a request     to scan the binarycontent for a terminating zero byte, possibly causing OpenSSL to read eitherless than or     beyond the end of the allocated buffer.

    Applications that pass attacker-supplied data to d2i_X509(), d2i_PKCS7(), orany other d2i_* decoding     function are affected. OpenSSL's own command-linetools are not vulnerable, as data read through the BIO     layer is checked beforeit reaches the affected code. The issue only affects 64-bit Unix and Unix-     likeplatforms; 32-bit platforms and 64-bit Windows are not affected.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by this issue,as the affected code is     outside the OpenSSL FIPS module boundary. (CVE-2026-34180)

    Issue summary: A specially crafted password-encrypted CMS messagecan trigger a NULL pointer dereference     during CMS decryption.

    Impact summary: This NULL pointer dereference leads to an application crashand a Denial of Service.

    The CMS PasswordRecipientInfo.keyDerivationAlgorithm field is defined asOPTIONAL in the ASN.1     specification and may therefore be absent in speciallycrafted inputs. During the password-based CMS     decryption the OpenSSLCMS implementation dereferences this field without first checking whether itwas     present.

    An attacker who supplies such a CMS message to an application performingpassword-based CMS decryption can     trigger an application crash, leading toa Denial of Service.

    Applications that process password-encrypted CMS messages may be affected.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by thisissue, as the affected code is     outside the OpenSSL FIPS module boundary. (CVE-2026-42766)

    Issue summary: A specially crafted PKCS#7 or S/MIME signed message couldtrigger a use-after-free during     PKCS#7 signature verification.

    Impact summary: A use-after-free may result in process crashes, heapcorruption, or potentially remote code     execution.

    When processing a PKCS#7 or S/MIME signed message, if the SignedDatadigestAlgorithms field is present as     an empty ASN.1 SET, OpenSSL mayincorrectly free a caller-owned BIO during PKCS7_verify(). A subsequentuse     of the BIO by the calling application results in a use-after-freecondition.

    In the common case this occurs when the application later callsBIO_free() on the BIO originally passed to     PKCS7_verify(). Dependingon allocator behavior and application-specific BIO usage patterns, thismay result     in a crash or other memory corruption. In some applicationcontexts this may potentially be exploitable for     remote code execution.

    Applications that process PKCS#7 or S/MIME signed messages using OpenSSLPKCS#7 APIs may be affected.
    Applications using the CMS APIs for thisprocessing are not affected.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by thisissue, as the affected code is     outside the OpenSSL FIPS module boundary. (CVE-2026-45447)

    Issue summary: A signed integer overflow when sizing the destinationbuffer for Unicode output in     ASN1_mbstring_ncopy() can lead to a heapbuffer overflow.

    Impact summary: A heap buffer overflow may lead to a crash or possiblyattacker controlled code execution     or other undefined behaviour.

    In ASN1_mbstring_copy() and ASN1_mbstring_ncopy() the destinationsize for Unicode output is computed in a     signed int: by left shiftof the input character count for BMPSTRING (UTF-16) andUNIVERSALSTRING (UTF-32),     and by summing per-character byte countsfor UTF8STRING. The calculation overflows when the input     reachesaround 2^30 characters. In the worst case (UNIVERSALSTRING at 2^30characters) the size wraps to     zero, OPENSSL_malloc(1) is called, andthe subsequent character copy writes several gigabytes past theone-     byte allocation.

    X.509 certificate processing routes through ASN1_STRING_set_by_NID(),whose DIRSTRING_TYPE mask excludes     UNIVERSALSTRING and whose per-NIDsize limits cap the input length; no network protocol orcertificate-     handling path in OpenSSL exercises the overflow.Triggering the bug requires an application that     callsASN1_mbstring_copy() or ASN1_mbstring_ncopy() directly, or registersa custom string type via     ASN1_STRING_TABLE_add(), withattacker-controlled input on the order of half a gigabyte or more.For these     reasons this issue was assigned Low severity.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected bythis issue, as the affected code is     outside the OpenSSL FIPS moduleboundary. (CVE-2026-7383)

    Issue summary: When CMS password-based decryption (RFC 3211 / PWRI key unwrap)processes attacker-supplied     CMS data, an attacker-chosen stream-mode KEKcipher can trigger a heap out-of-bounds read in     kek_unwrap_key().

    Impact summary: A heap buffer over-read may trigger a crash which leads toDenial of Service for an     application if the input buffer ends at a memorypage boundary and the following page is unmapped. There is     no informationdisclosure as the over-read bytes are not revealed to the attacker.

    The key unwrapping function performs a check-byte test as specified in theRFC that reads 7 bytes from a     heap allocation that is based on the wrappedkey length from the message. There is a minimum length check     based on theblock length of the wrapping cipher. However the cipher is selected froman OID carried in the     attacker's PWRI keyEncryptionAlgorithm with norequirement that the cipher be a block cipher. When an     attacker selectsa stream-mode cipher the guard will be ineffective and the allocated buffercontaining the     unwrapped key can be too small to fit the check-bytesspecified in the RFC and a buffer over-read can     happen.

    Applications calling CMS_decrypt() or CMS_decrypt_set1_password()(equivalently openssl cms -decrypt
    -pwri_password ...) on untrusted CMSdata are vulnerable to this issue. No password knowledge is required:
    theover-read happens during the unwrap attempt before any authenticationsucceeds.

    The over-read is limited to a few bytes and is not written to output, sothere is no information     disclosure. Triggering a crash requires theallocation to border unmapped memory, which is unlikely with     the normalallocator.

    The FIPS modules are not affected by this issue. (CVE-2026-9076)

Tenable has extracted the preceding description block directly from the tested product security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

The remote SUSE Linux SLES15 / SLES_SAP15 host has packages installed that are affected by multiple vulnerabilities as referenced in the SUSE-SU-2026:2614-1 advisory.

    - CVE-2026-45447: Heap Use-After-Free in OpenSSL PKCS7_verify() (bsc#1266357).
    - CVE-2026-42766: Possible NULL Dereference in Password-Based CMS Decryption (bsc#1266349).
    - CVE-2026-9076:  Out-of-Bounds Read in CMS Password-Based Decryption (bsc#1266341).
    - CVE-2026-7383:  Possible Heap Buffer Overflow in ASN.1 Multibyte String Conversion (bsc#1266340).
    - CVE-2026-34180: Heap Buffer Over-read in ASN.1 Content Parsing (bsc#1266342).

Tenable has extracted the preceding description block directly from the SUSE security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

The remote MiracleLinux 9 host has packages installed that are affected by multiple vulnerabilities as referenced in the AXSA:2026-1339:14 advisory.

    * openssl: OpenSSL: Heap buffer overflow due to signed integer overflow in Unicode output sizing     (CVE-2026-7383)
      * openssl: OpenSSL: Denial of Service due to heap out-of-bounds read in CMS password-based decryption     (CVE-2026-9076)
      * openssl: OpenSSL: Heap buffer over-read in ASN.1 decoding can lead to denial of service or information     disclosure. (CVE-2026-34180)
      * openssl: PKCS#12 Files with PBMAC1 Are Accepted with Short HMAC Keys (CVE-2026-34181)
      * openssl: CMS AuthEnvelopedData Processing May Accept Forged Messages (CVE-2026-34182)
      * openssl: Unbounded Memory Growth in the QUIC PATH_CHALLENGE Handler (CVE-2026-34183)
      * openssl: NULL pointer dereference in QUIC server initial packet handling (CVE-2026-42764)
      * openssl: Possible NULL Dereference in Password-Based CMS Decryption (CVE-2026-42766)
      * openssl: NULL Pointer Dereference in CRMF EncryptedValue Decryption (CVE-2026-42767)
      * openssl: Multi-RecipientInfo Bleichenbacher Oracle in CMS_decrypt() and PKCS7_decrypt()     (CVE-2026-42768)
      * openssl: Trust-Anchor Substitution via cert/issuer Typo in CMP rootCaKeyUpdate (CVE-2026-42769)
      * openssl: FFC-DH Peer Validation Uses Attacker-Supplied q (CVE-2026-42770)
      * openssl: AES-OCB IV Ignored on EVP_Cipher() Path (CVE-2026-45445)
      * openssl: Incorrect Tag Processing for Empty Messages in AES-GCM-SIV and AES-SIV modes (CVE-2026-45446)
      * openssl: Heap Use-After-Free in OpenSSL PKCS7_verify() (CVE-2026-45447)

Tenable has extracted the preceding description block directly from the MiracleLinux security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

The remote Oracle Linux 10 host has packages installed that are affected by multiple vulnerabilities as referenced in the ELSA-2026-25237 advisory.

    - Patch asn1_d2i_read_bio to read headers without blocking       Resolves: RHEL-169991

    Fix CVE-2026-7383, CVE-2026-9076, CVE-2026-34180, CVE-2026-34181,     CVE-2026-34183, CVE-2026-42764, CVE-2026-42766, CVE-2026-42767, CVE-2026-42768,     CVE-2026-42769, CVE-2026-42770, CVE-2026-45445, CVE-2026-45446, CVE-2026-45447,     CVE-2026-34182.
    Resolves: RHEL-179267     Resolves: RHEL-179281     Resolves: RHEL-179537     Resolves: RHEL-179542     Resolves: RHEL-179545     Resolves: RHEL-179550     Resolves: RHEL-179553     Resolves: RHEL-179626     Resolves: RHEL-179658     Resolves: RHEL-179675     Resolves: RHEL-179682     Resolves: RHEL-179685     Resolves: RHEL-179689     Resolves: RHEL-179693     Resolves: RHEL-179697

Tenable has extracted the preceding description block directly from the Oracle Linux security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

According to the versions of the openssl packages installed, the EulerOS installation on the remote host is affected by the following vulnerabilities :

    Issue summary: A signed integer overflow when sizing the destination_x000D_     buffer for Unicode output in ASN1_mbstring_ncopy() can lead to a heap_x000D_     buffer overflow._x000D_
    _x000D_     Impact summary: A heap buffer overflow may lead to a crash or possibly_x000D_     attacker controlled code execution or other undefined behaviour._x000D_
    _x000D_     In ASN1_mbstring_copy() and ASN1_mbstring_ncopy() the destination_x000D_     size for Unicode output is computed in a signed int: by left shift_x000D_     of the input character count for BMPSTRING (UTF-16) and_x000D_     UNIVERSALSTRING (UTF-32), and by summing per-character byte counts_x000D_     for UTF8STRING. The calculation overflows when the input reaches_x000D_     around 2^30 characters. In the worst case (UNIVERSALSTRING at 2^30_x000D_     characters) the size wraps to zero, OPENSSL_malloc(1) is called, and_x000D_     the subsequent character copy writes several gigabytes past the_x000D_     one-byte allocation._x000D_
    _x000D_     X.509 certificate processing routes through ASN1_STRING_set_by_NID(),_x000D_     whose DIRSTRING_TYPE mask excludes UNIVERSALSTRING and whose per-NID_x000D_     size limits cap the input length; no network protocol or_x000D_     certificate-handling path in OpenSSL exercises the overflow._x000D_     Triggering the bug requires an application that calls_x000D_     ASN1_mbstring_copy() or ASN1_mbstring_ncopy() directly, or registers_x000D_     a custom string type via ASN1_STRING_TABLE_add(), with_x000D_     attacker-controlled input on the order of half a gigabyte or more._x000D_     For these reasons this issue was assigned Low severity._x000D_
    _x000D_     The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by_x000D_     this issue, as the affected code is outside the OpenSSL FIPS module_x000D_     boundary.(CVE-2026-7383)

    Issue summary: When EVP_PKEY_derive_set_peer() is called with a DHX (X9.42) peer key, the peer key is not     properly checked for the subgroup membership. Impact summary: A malicious peer which presents an X9.42 key     carrying the victim's p and g parameters, a forged q = r (a small prime factor of the cofactor     (p-1)/q_local), and a public value Y of order r can recover the victim's private key after a small number     of key exchange attempts. When EVP_PKEY_derive_set_peer() is called with a DHX (X9.42) peer key, the     subgroup membership check Y^q ? 1 (mod p) is performed using the peer's own q parameter, not the local     key's q. The peer's domain parameters are then matched against the domain parameters of the private key,     but the value of q is not compared. A malicious peer who presents an X9.42 key carrying the victim's p, g,     a forged q = r (a small prime factor of the cofactor), and a public value Y of order r passes all checks.
    The shared secret then takes only r distinct values, leaking priv mod r. Repeating for each small-prime     factor of the cofactor and combining via CRT recovers the full private key (Lim-Lee / small-subgroup-     confinement attack). The realistic attack surface is narrow: principally CMP deployments with long-lived     RA/CA DHX keys and bespoke enterprise or government applications using X9.42 DHX static keys with     interactive protocols and therefore this issue was assigned Low severity. The FIPS modules in 4.0, 3.6,     3.5, 3.4, and 3.0 are affected by this issue.(CVE-2026-42770)

    Issue summary: When CMS password-based decryption (RFC 3211 / PWRI key unwrap)_x000D_     processes attacker-supplied CMS data, an attacker-chosen stream-mode KEK_x000D_     cipher can trigger a heap out-of-bounds read in kek_unwrap_key()._x000D_
    _x000D_     Impact summary: A heap buffer over-read may trigger a crash which leads to_x000D_     Denial of Service for an application if the input buffer ends at a memory_x000D_     page boundary and the following page is unmapped. There is no information_x000D_     disclosure as the over-read bytes are not revealed to the attacker._x000D_
    _x000D_     The key unwrapping function performs a check-byte test as specified in the_x000D_     RFC that reads 7 bytes from a heap allocation that is based on the wrapped_x000D_     key length from the message. There is a minimum length check based on the_x000D_     block length of the wrapping cipher. However the cipher is selected from_x000D_     an OID carried in the attacker's PWRI keyEncryptionAlgorithm with no_x000D_     requirement that the cipher be a block cipher. When an attacker selects_x000D_     a stream-mode cipher the guard will be ineffective and the allocated buffer_x000D_     containing the unwrapped key can be too small to fit the check-bytes_x000D_     specified in the RFC and a buffer over-read can happen._x000D_
    _x000D_     Applications calling CMS_decrypt() or CMS_decrypt_set1_password()_x000D_     (equivalently openssl cms -decrypt -pwri_password ...) on untrusted CMS_x000D_     data are vulnerable to this issue. No password knowledge is required: the_x000D_     over-read happens during the unwrap attempt before any authentication_x000D_     succeeds._x000D_
    _x000D_     The over-read is limited to a few bytes and is not written to output, so_x000D_     there is no information disclosure. Triggering a crash requires the_x000D_     allocation to border unmapped memory, which is unlikely with the normal_x000D_     allocator._x000D_
    _x000D_     The FIPS modules are not affected by this issue.(CVE-2026-9076)

    Issue summary: When an application drives an AES-OCB context through the_x000D_     public EVP_Cipher() one-shot interface, the application-supplied_x000D_     initialisation vector (IV) is silently discarded._x000D_
    _x000D_     Impact summary: Every message encrypted under the same key uses the_x000D_     same effective nonce regardless of the IV supplied by the caller,_x000D_     resulting in (key, nonce) reuse and loss of confidentiality.  If the_x000D_     same code path is used to compute the authentication tag, the tag_x000D_     depends only on the (key, IV) pair and not on the plaintext or_x000D_     ciphertext, allowing universal forgery of arbitrary ciphertext from a_x000D_     single captured message._x000D_
    _x000D_     OpenSSL provides two ways to drive a cipher: the documented streaming_x000D_     interface (EVP_CipherUpdate / EVP_CipherFinal_ex) and a lower-level_x000D_     one-shot, EVP_Cipher(), whose documentation explicitly recommends_x000D_     against use by applications in favour of EVP_CipherUpdate() and_x000D_     EVP_CipherFinal_ex().  The OCB provider's streaming handler flushes_x000D_     the application-supplied IV into the OCB context before processing_x000D_     data; the one-shot handler did not.  Every call to EVP_Cipher() on an_x000D_     AES-OCB context therefore ran with the all-zero key-derived offset_x000D_     state left by cipher initialisation, regardless of the caller's IV._x000D_
    _x000D_     If EVP_EncryptFinal_ex() is subsequently used to obtain the_x000D_     authentication tag, the deferred IV setup runs at that point and_x000D_     clears the running checksum that should have been accumulated over the_x000D_     plaintext.  The resulting tag is a function of (key, IV) only and_x000D_     verifies against any ciphertext produced under the same (key, IV)_x000D_     pair._x000D_
    _x000D_     The OpenSSL SSL/TLS implementation is not affected: AES-OCB is not a_x000D_     TLS cipher suite, and libssl does not call EVP_Cipher() in any case._x000D_     Applications that drive AES-OCB through the documented streaming AEAD_x000D_     API (EVP_CipherUpdate / EVP_CipherFinal_ex) are not affected.  Only_x000D_     applications that combine the AES-OCB cipher with the EVP_Cipher()_x000D_     one-shot API are vulnerable._x000D_
    _x000D_     The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by_x000D_     this issue, as AES-OCB is outside the OpenSSL FIPS module boundary.(CVE-2026-45445)

    Issue summary: An attacker-controlled CMP (Certificate Management Protocol)_x000D_     server could trigger a NULL pointer dereference in a CMP client application._x000D_
    _x000D_     Impact summary: A NULL pointer dereference causes a crash of the_x000D_     application and a Denial of Service._x000D_
    _x000D_     An attacker controlling a CMP server (or acting as a man-in-the-middle) could_x000D_     craft a CMP response containing a CRMF (Certificate Request Message Format)_x000D_     CertRepMessage with an EncryptedValue structure where the symmAlg field_x000D_     has an algorithm OID but no parameters field. When the OpenSSL CMP client_x000D_     processes this response, the NULL dereference occurs, causing a crash of_x000D_     the CMP client._x000D_
    _x000D_     Applications that process untrusted CMP/CRMF messages may be affected._x000D_
    _x000D_     The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this_x000D_     issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-42767)

    Issue summary: The implementations of AES-SIV (RFC 5297) and AES-GCM-SIV_x000D_     (RFC 8452) mishandle the authentication of AAD (Additional Authenticated_x000D_     Data) with an empty ciphertext allowing a forgery of such messages._x000D_
    _x000D_     Impact summary: An attacker can forge empty messages with arbitrary AAD_x000D_     to the victim's application using these ciphers._x000D_
    _x000D_     AES-SIV (RFC 5297) and AES-GCM-SIV (RFC 8452) are nonce-misuse-resistant AEAD_x000D_     modes: they accept a key, nonce, optional AAD (bytes that are authenticated_x000D_     but not encrypted), and plaintext, and produces ciphertext plus a 16-byte_x000D_     tag. On decrypt, `EVP_DecryptFinal_ex()` is documented to return success only_x000D_     if the tag is verified succesfully._x000D_
    _x000D_     In OpenSSL's provider implementation of these ciphers, the expected tag is_x000D_     computed only when decryption function is invoked with non-empty data._x000D_     If the caller supplies AAD and then calls `EVP_DecryptFinal_ex()` without_x000D_     invocation of the ciphertext update, which can happen when the received_x000D_     ciphertext length is zero, the tag is never recalculated and still holds its_x000D_     all-zeros value._x000D_
    _x000D_     When AES-GCM-SIV is used, an attacker who sends arbitrary AAD, empty_x000D_     ciphertext, and all-zeros tag passes authentication under any key they do not_x000D_     know, single-shot. When AES-SIV is used, for mounting the attack it's_x000D_     necessary for the application to reuse the decryption context without_x000D_     resetting the key._x000D_
    _x000D_     AES-SIV is implemented since OpenSSL 3.0. AES-GCM-SIV is implemented since_x000D_     OpenSSL 3.2._x000D_
    _x000D_     No protocols implemented in OpenSSL itself (TLS/CMS/PKCS7/HPKE/QUIC) support_x000D_     either AES-GCM-SIV or AES-SIV. To mount an attack, the applications must_x000D_     implement their own protocol and use the EVP interface. Also they must skip the_x000D_     ciphertext update when a message with an empty ciphertext arrives._x000D_
    _x000D_     The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this_x000D_     issue, as these algorithms are not FIPS approved and the affected code is_x000D_     outside the OpenSSL FIPS module boundary.(CVE-2026-45446)

    Issue summary: Parsing a crafted DER-encoded ASN.1 structure with a primitive_x000D_     element whose content exceeds 2 gigabytes in length may cause a heap buffer_x000D_     over-read on 64-bit Unix and Unix-like platforms._x000D_
    _x000D_     Impact summary: The heap buffer over-read may crash the application (Denial of_x000D_     Service) or to load into the decoded ASN.1 object contents of memory beyond the_x000D_     end of the input buffer.  More typically such ASN.1 elements would instead be_x000D_     truncated._x000D_
    _x000D_     An integer truncation in OpenSSL's ASN.1 decoder causes the content length of_x000D_     an ASN.1 primitive element to be mishandled when it exceeds 2 gigabytes. In the_x000D_     worst case the truncated length is treated as a request to scan the binary_x000D_     content for a terminating zero byte, possibly causing OpenSSL to read either_x000D_     less than or beyond the end of the allocated buffer._x000D_
    _x000D_     Applications that pass attacker-supplied data to d2i_X509(), d2i_PKCS7(), or_x000D_     any other d2i_* decoding function are affected. OpenSSL's own command-line_x000D_     tools are not vulnerable, as data read through the BIO layer is checked before_x000D_     it reaches the affected code. The issue only affects 64-bit Unix and Unix-like_x000D_     platforms; 32-bit platforms and 64-bit Windows are not affected._x000D_
    _x000D_     The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by this issue,_x000D_     as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-34180)

    Issue summary: A specially crafted password-encrypted CMS message_x000D_     can trigger a NULL pointer dereference during CMS decryption._x000D_
    _x000D_     Impact summary: This NULL pointer dereference leads to an application crash_x000D_     and a Denial of Service._x000D_
    _x000D_     The CMS PasswordRecipientInfo.keyDerivationAlgorithm field is defined as_x000D_     OPTIONAL in the ASN.1 specification and may therefore be absent in specially_x000D_     crafted inputs. During the password-based CMS decryption the OpenSSL_x000D_     CMS implementation dereferences this field without first checking whether it_x000D_     was present._x000D_
    _x000D_     An attacker who supplies such a CMS message to an application performing_x000D_     password-based CMS decryption can trigger an application crash, leading to_x000D_     a Denial of Service._x000D_
    _x000D_     Applications that process password-encrypted CMS messages may be affected._x000D_
    _x000D_     The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this_x000D_     issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-42766)

    Issue summary: A specially crafted PKCS#7 or S/MIME signed message could_x000D_     trigger a use-after-free during PKCS#7 signature verification._x000D_
    _x000D_     Impact summary: A use-after-free may result in process crashes, heap_x000D_     corruption, or potentially remote code execution._x000D_
    _x000D_     When processing a PKCS#7 or S/MIME signed message, if the SignedData_x000D_     digestAlgorithms field is present as an empty ASN.1 SET, OpenSSL may_x000D_     incorrectly free a caller-owned BIO during PKCS7_verify(). A subsequent_x000D_     use of the BIO by the calling application results in a use-after-free_x000D_     condition._x000D_
    _x000D_     In the common case this occurs when the application later calls_x000D_     BIO_free() on the BIO originally passed to PKCS7_verify(). Depending_x000D_     on allocator behavior and application-specific BIO usage patterns, this_x000D_     may result in a crash or other memory corruption. In some application_x000D_     contexts this may potentially be exploitable for remote code execution._x000D_
    _x000D_     Applications that process PKCS#7 or S/MIME signed messages using OpenSSL_x000D_     PKCS#7 APIs may be affected. Applications using the CMS APIs for this_x000D_     processing are not affected._x000D_
    _x000D_     The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this_x000D_     issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-45447)

    Issue Summary: Cryptographic Message Services (CMS) processing fails to perform_x000D_     sufficient input validation on the cipher and tag length fields of_x000D_     AuthEnvelopedData containers, leading to various potential compromises._x000D_
    _x000D_     Impact Summary: Attackers making use of these vulnerabilities may achieve_x000D_     key-equivalent functionality for a given CMS recipient and/or bypass integrity_x000D_     validation for a given message._x000D_
    _x000D_     In one use case, an attacker may send a CMS message containing_x000D_     AuthEnvelopedData with the cipher specified as a non-AEAD cipher.  OpenSSL_x000D_     erroneously allows this selection, and attempts to decrypt and validate the_x000D_     message._x000D_
    _x000D_     An on-path attacker who captures one legitimate AES-GCM AuthEnvelopedData_x000D_     addressed to the victim can re-emit it with the recipientInfos set left_x000D_     byte-for-byte intact, so the victim's private key still unwraps the genuine CEK_x000D_     (the content-encryption key), but with the inner OID rewritten to AES-256-OFB_x000D_     (Output Feedback Mode, an unauthenticated keystream mode) and with an_x000D_     attacker-chosen IV and ciphertext. The victim initializes AES-256-OFB under the_x000D_     real CEK, never consults the MAC field, and CMS_decrypt() returns success._x000D_
    _x000D_     If the application under attack responds to the attacker with any indicator_x000D_     showing success or failure of the decryption effort, it is possible for the_x000D_     attacker to use this as an oracle to obtain key equivalent functionality for the_x000D_     CEK used for the chosen recipient of the message._x000D_
    _x000D_     In another use case, an attacker can reduce the tag length of the chosen AEAD_x000D_     cipher for a given AuthEnvelopedData container to be a single byte long,_x000D_     allowing an attacker to brute force CMS decryption, producing an integrity_x000D_     bypass for applications that trust CMS_decrypt() to reject modified content._x000D_
    _x000D_     The FIPS modules are not affected by this issue.(CVE-2026-34182)

Tenable has extracted the preceding description block directly from the EulerOS openssl security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

An update of the openssl package has been released.

The remote SUSE Linux SLES15 / SLES_SAP15 host has packages installed that are affected by multiple vulnerabilities as referenced in the SUSE-SU-2026:2397-1 advisory.

    This update for openssl-3 fixes the following issues

    - CVE-2026-7383: Possible Heap Buffer Overflow in ASN.1 Multibyte String Conversion (bsc#1266340).
    - CVE-2026-9076: Out-of-Bounds Read in CMS Password-Based Decryption (bsc#1266341).
    - CVE-2026-34180: Heap Buffer Over-read in ASN.1 Content Parsing (bsc#1266342).
    - CVE-2026-42766: Possible NULL Dereference in Password-Based CMS Decryption (bsc#1266349).
    - CVE-2026-42770: FFC-DH Peer Validation Uses Attacker-Supplied q (bsc#1266353).
    - CVE-2026-45445: AES-OCB IV Ignored on EVP_Cipher() Path (bsc#1266355).
    - CVE-2026-45446: Incorrect Tag Processing for Empty Messages in AES-GCM-SIV and AES-SIV modes     (bsc#1266356).
    - CVE-2026-45447: Heap Use-After-Free in OpenSSL PKCS7_verify() (bsc#1266357).

Tenable has extracted the preceding description block directly from the SUSE security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

The version of OpenSSL installed on the remote host is prior to 1.0.2zq. It is, therefore, affected by multiple vulnerabilities as referenced in the 1.0.2zq advisory.

  - Issue summary: A specially crafted password-encrypted CMS message can trigger a NULL pointer dereference     during CMS decryption. Impact summary: This NULL pointer dereference leads to an application crash and a     Denial of Service. The CMS PasswordRecipientInfo.keyDerivationAlgorithm field is defined as OPTIONAL in     the ASN.1 specification and may therefore be absent in specially crafted inputs. During the password-based     CMS decryption the OpenSSL CMS implementation dereferences this field without first checking whether it     was present. An attacker who supplies such a CMS message to an application performing password-based CMS     decryption can trigger an application crash, leading to a Denial of Service. Applications that process     password-encrypted CMS messages may be affected. The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not     affected by this issue, as the affected code is outside the OpenSSL FIPS module boundary. (CVE-2026-42766)

  - Issue summary: A signed integer overflow when sizing the destination buffer for Unicode output in     ASN1_mbstring_ncopy() can lead to a heap buffer overflow. Impact summary: A heap buffer overflow may lead     to a crash or possibly attacker controlled code execution or other undefined behaviour. In     ASN1_mbstring_copy() and ASN1_mbstring_ncopy() the destination size for Unicode output is computed in a     signed int: by left shift of the input character count for BMPSTRING (UTF-16) and UNIVERSALSTRING     (UTF-32), and by summing per-character byte counts for UTF8STRING. The calculation overflows when the     input reaches around 2^30 characters. In the worst case (UNIVERSALSTRING at 2^30 characters) the size     wraps to zero, OPENSSL_malloc(1) is called, and the subsequent character copy writes several gigabytes     past the one-byte allocation. X.509 certificate processing routes through ASN1_STRING_set_by_NID(), whose     DIRSTRING_TYPE mask excludes UNIVERSALSTRING and whose per-NID size limits cap the input length; no     network protocol or certificate-handling path in OpenSSL exercises the overflow. Triggering the bug     requires an application that calls ASN1_mbstring_copy() or ASN1_mbstring_ncopy() directly, or registers a     custom string type via ASN1_STRING_TABLE_add(), with attacker-controlled input on the order of half a     gigabyte or more. For these reasons this issue was assigned Low severity. The FIPS modules in 4.0, 3.6,     3.5, 3.4 and 3.0 are not affected by this issue, as the affected code is outside the OpenSSL FIPS module     boundary. (CVE-2026-7383)

  - Issue summary: When CMS password-based decryption (RFC 3211 / PWRI key unwrap) processes attacker-supplied     CMS data, an attacker-chosen stream-mode KEK cipher can trigger a heap out-of-bounds read in     kek_unwrap_key(). Impact summary: A heap buffer over-read may trigger a crash which leads to Denial of     Service for an application if the input buffer ends at a memory page boundary and the following page is     unmapped. There is no information disclosure as the over-read bytes are not revealed to the attacker. The     key unwrapping function performs a check-byte test as specified in the RFC that reads 7 bytes from a heap     allocation that is based on the wrapped key length from the message. There is a minimum length check based     on the block length of the wrapping cipher. However the cipher is selected from an OID carried in the     attacker's PWRI keyEncryptionAlgorithm with no requirement that the cipher be a block cipher. When an     attacker selects a stream-mode cipher the guard will be ineffective and the allocated buffer containing     the unwrapped key can be too small to fit the check-bytes specified in the RFC and a buffer over-read can     happen. Applications calling CMS_decrypt() or CMS_decrypt_set1_password() (equivalently openssl cms
    -decrypt -pwri_password ...) on untrusted CMS data are vulnerable to this issue. No password knowledge is     required: the over-read happens during the unwrap attempt before any authentication succeeds. The over-     read is limited to a few bytes and is not written to output, so there is no information disclosure.
    Triggering a crash requires the allocation to border unmapped memory, which is unlikely with the normal     allocator. The FIPS modules are not affected by this issue. (CVE-2026-9076)

  - Issue summary: A specially crafted PKCS#7 or S/MIME signed message could trigger a use-after-free during     PKCS#7 signature verification. Impact summary: A use-after-free may result in process crashes, heap     corruption, or potentially remote code execution. When processing a PKCS#7 or S/MIME signed message, if     the SignedData digestAlgorithms field is present as an empty ASN.1 SET, OpenSSL may incorrectly free a     caller-owned BIO during PKCS7_verify(). A subsequent use of the BIO by the calling application results in     a use-after-free condition. In the common case this occurs when the application later calls BIO_free() on     the BIO originally passed to PKCS7_verify(). Depending on allocator behavior and application-specific BIO     usage patterns, this may result in a crash or other memory corruption. In some application contexts this     may potentially be exploitable for remote code execution. Applications that process PKCS#7 or S/MIME     signed messages using OpenSSL PKCS#7 APIs may be affected. Applications using the CMS APIs for this     processing are not affected. The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this     issue, as the affected code is outside the OpenSSL FIPS module boundary. (CVE-2026-45447)

  - Issue summary: Parsing a crafted DER-encoded ASN.1 structure with a primitive element whose content     exceeds 2 gigabytes in length may cause a heap buffer over-read on 64-bit Unix and Unix-like platforms.
    Impact summary: The heap buffer over-read may crash the application (Denial of Service) or to load into     the decoded ASN.1 object contents of memory beyond the end of the input buffer. More typically such ASN.1     elements would instead be truncated. An integer truncation in OpenSSL's ASN.1 decoder causes the content     length of an ASN.1 primitive element to be mishandled when it exceeds 2 gigabytes. In the worst case the     truncated length is treated as a request to scan the binary content for a terminating zero byte, possibly     causing OpenSSL to read either less than or beyond the end of the allocated buffer. Applications that pass     attacker-supplied data to d2i_X509(), d2i_PKCS7(), or any other d2i_* decoding function are affected.
    OpenSSL's own command-line tools are not vulnerable, as data read through the BIO layer is checked before     it reaches the affected code. The issue only affects 64-bit Unix and Unix-like platforms; 32-bit platforms     and 64-bit Windows are not affected. The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by     this issue, as the affected code is outside the OpenSSL FIPS module boundary. (CVE-2026-34180)

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

The remote SUSE Linux SLES12 host has packages installed that are affected by multiple vulnerabilities as referenced in the SUSE-SU-2026:2396-1 advisory.

    This update for openssl-1_0_0 fixes the following issues

    - CVE-2026-7383: Possible Heap Buffer Overflow in ASN.1 Multibyte String Conversion (bsc#1266340).
    - CVE-2026-9076: Out-of-Bounds Read in CMS Password-Based Decryption (bsc#1266341).
    - CVE-2026-28388: NULL Pointer Dereference When Processing a Delta CRL (bsc#1260442).
    - CVE-2026-28389: Possible NULL dereference when processing CMS KeyAgreeRecipientInfo (bsc#1260443).
    - CVE-2026-34180: Heap Buffer Over-read in ASN.1 Content Parsing (bsc#1266342).
    - CVE-2026-42766: Possible NULL Dereference in Password-Based CMS Decryption (bsc#1266349).
    - CVE-2026-45447: Heap Use-After-Free in OpenSSL PKCS7_verify() (bsc#1266357).
    - NULL pointer dereference when processing an OCSP response (bsc#1260446).

Tenable has extracted the preceding description block directly from the SUSE security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

According to the versions of the shim packages installed, the EulerOS installation on the remote host is affected by the following vulnerabilities :

    Issue summary: A specially crafted PKCS#7 or S/MIME signed message could     trigger a use-after-free during PKCS#7 signature verification.

    Impact summary: A use-after-free may result in process crashes, heap     corruption, or potentially remote code execution.

    When processing a PKCS#7 or S/MIME signed message, if the SignedData     digestAlgorithms field is present as an empty ASN.1 SET, OpenSSL may     incorrectly free a caller-owned BIO during PKCS7_verify(). A subsequent     use of the BIO by the calling application results in a use-after-free     condition.

    In the common case this occurs when the application later calls     BIO_free() on the BIO originally passed to PKCS7_verify(). Depending     on allocator behavior and application-specific BIO usage patterns, this     may result in a crash or other memory corruption. In some application     contexts this may potentially be exploitable for remote code execution.

    Applications that process PKCS#7 or S/MIME signed messages using OpenSSL     PKCS#7 APIs may be affected. Applications using the CMS APIs for this     processing are not affected.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this     issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-45447)

    Issue summary: Parsing a crafted DER-encoded ASN.1 structure with a primitive     element whose content exceeds 2 gigabytes in length may cause a heap buffer     over-read on 64-bit Unix and Unix-like platforms.

    Impact summary: The heap buffer over-read may crash the application (Denial of     Service) or to load into the decoded ASN.1 object contents of memory beyond the     end of the input buffer.  More typically such ASN.1 elements would instead be     truncated.

    An integer truncation in OpenSSL's ASN.1 decoder causes the content length of     an ASN.1 primitive element to be mishandled when it exceeds 2 gigabytes. In the     worst case the truncated length is treated as a request to scan the binary     content for a terminating zero byte, possibly causing OpenSSL to read either     less than or beyond the end of the allocated buffer.

    Applications that pass attacker-supplied data to d2i_X509(), d2i_PKCS7(), or     any other d2i_* decoding function are affected. OpenSSL's own command-line     tools are not vulnerable, as data read through the BIO layer is checked before     it reaches the affected code. The issue only affects 64-bit Unix and Unix-like     platforms; 32-bit platforms and 64-bit Windows are not affected.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by this issue,     as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-34180)

    Issue summary: A signed integer overflow when sizing the destination     buffer for Unicode output in ASN1_mbstring_ncopy() can lead to a heap     buffer overflow.

    Impact summary: A heap buffer overflow may lead to a crash or possibly     attacker controlled code execution or other undefined behaviour.

    In ASN1_mbstring_copy() and ASN1_mbstring_ncopy() the destination     size for Unicode output is computed in a signed int: by left shift     of the input character count for BMPSTRING (UTF-16) and     UNIVERSALSTRING (UTF-32), and by summing per-character byte counts     for UTF8STRING. The calculation overflows when the input reaches     around 2^30 characters. In the worst case (UNIVERSALSTRING at 2^30     characters) the size wraps to zero, OPENSSL_malloc(1) is called, and     the subsequent character copy writes several gigabytes past the     one-byte allocation.

    X.509 certificate processing routes through ASN1_STRING_set_by_NID(),     whose DIRSTRING_TYPE mask excludes UNIVERSALSTRING and whose per-NID     size limits cap the input length; no network protocol or     certificate-handling path in OpenSSL exercises the overflow.
    Triggering the bug requires an application that calls     ASN1_mbstring_copy() or ASN1_mbstring_ncopy() directly, or registers     a custom string type via ASN1_STRING_TABLE_add(), with     attacker-controlled input on the order of half a gigabyte or more.
    For these reasons this issue was assigned Low severity.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by     this issue, as the affected code is outside the OpenSSL FIPS module     boundary.(CVE-2026-7383)

Tenable has extracted the preceding description block directly from the EulerOS shim security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

According to the versions of the shim package installed, the EulerOS installation on the remote host is affected by the following vulnerabilities :

    Issue summary: A specially crafted PKCS#7 or S/MIME signed message could     trigger a use-after-free during PKCS#7 signature verification.

    Impact summary: A use-after-free may result in process crashes, heap     corruption, or potentially remote code execution.

    When processing a PKCS#7 or S/MIME signed message, if the SignedData     digestAlgorithms field is present as an empty ASN.1 SET, OpenSSL may     incorrectly free a caller-owned BIO during PKCS7_verify(). A subsequent     use of the BIO by the calling application results in a use-after-free     condition.

    In the common case this occurs when the application later calls     BIO_free() on the BIO originally passed to PKCS7_verify(). Depending     on allocator behavior and application-specific BIO usage patterns, this     may result in a crash or other memory corruption. In some application     contexts this may potentially be exploitable for remote code execution.

    Applications that process PKCS#7 or S/MIME signed messages using OpenSSL     PKCS#7 APIs may be affected. Applications using the CMS APIs for this     processing are not affected.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this     issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-45447)

    Issue summary: Parsing a crafted DER-encoded ASN.1 structure with a primitive     element whose content exceeds 2 gigabytes in length may cause a heap buffer     over-read on 64-bit Unix and Unix-like platforms.

    Impact summary: The heap buffer over-read may crash the application (Denial of     Service) or to load into the decoded ASN.1 object contents of memory beyond the     end of the input buffer.  More typically such ASN.1 elements would instead be     truncated.

    An integer truncation in OpenSSL's ASN.1 decoder causes the content length of     an ASN.1 primitive element to be mishandled when it exceeds 2 gigabytes. In the     worst case the truncated length is treated as a request to scan the binary     content for a terminating zero byte, possibly causing OpenSSL to read either     less than or beyond the end of the allocated buffer.

    Applications that pass attacker-supplied data to d2i_X509(), d2i_PKCS7(), or     any other d2i_* decoding function are affected. OpenSSL's own command-line     tools are not vulnerable, as data read through the BIO layer is checked before     it reaches the affected code. The issue only affects 64-bit Unix and Unix-like     platforms; 32-bit platforms and 64-bit Windows are not affected.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by this issue,     as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-34180)

    Issue summary: A signed integer overflow when sizing the destination     buffer for Unicode output in ASN1_mbstring_ncopy() can lead to a heap     buffer overflow.

    Impact summary: A heap buffer overflow may lead to a crash or possibly     attacker controlled code execution or other undefined behaviour.

    In ASN1_mbstring_copy() and ASN1_mbstring_ncopy() the destination     size for Unicode output is computed in a signed int: by left shift     of the input character count for BMPSTRING (UTF-16) and     UNIVERSALSTRING (UTF-32), and by summing per-character byte counts     for UTF8STRING. The calculation overflows when the input reaches     around 2^30 characters. In the worst case (UNIVERSALSTRING at 2^30     characters) the size wraps to zero, OPENSSL_malloc(1) is called, and     the subsequent character copy writes several gigabytes past the     one-byte allocation.

    X.509 certificate processing routes through ASN1_STRING_set_by_NID(),     whose DIRSTRING_TYPE mask excludes UNIVERSALSTRING and whose per-NID     size limits cap the input length; no network protocol or     certificate-handling path in OpenSSL exercises the overflow.
    Triggering the bug requires an application that calls     ASN1_mbstring_copy() or ASN1_mbstring_ncopy() directly, or registers     a custom string type via ASN1_STRING_TABLE_add(), with     attacker-controlled input on the order of half a gigabyte or more.
    For these reasons this issue was assigned Low severity.

    The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by     this issue, as the affected code is outside the OpenSSL FIPS module     boundary.(CVE-2026-7383)

Tenable has extracted the preceding description block directly from the EulerOS shim security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

The remote NewStart CGSL host, running version MAIN 7.02, has tongsuo packages installed that are affected by multiple vulnerabilities:

 - Issue summary: An uncommon configuration of clients performing DANE TLSA-based server authentication, when paired with uncommon server DANE TLSA records, may result in a use-after-free and/or double-free on the client side. Impact summary: A use after free can have a range of potential consequences such as the corruption of valid data, crashes or execution of arbitrary code. However, the issue only affects clients that make use of TLSA records with both the PKIX-TA(0/PKIX-EE(1) certificate usages and the DANE-TA(2) certificate usage. By far the most common deployment of DANE is in SMTP MTAs for which RFC7672 recommends that clients treat as 'unusable' any TLSA records that have the PKIX certificate usages. These SMTP (or other similar) clients are not vulnerable to this issue. Conversely, any clients that support only the PKIX usages, and ignore the DANE-TA(2) usage are also not vulnerable. The client would also need to be communicating with a server that publishes a TLSA RRset with both types of TLSA records. No FIPS modules are affected by this issue, the problem code is outside the FIPS module boundary. (CVE-2026-28387)

 - Issue summary: Writing large, newline-free data into a BIO chain using the line-buffering filter where the next BIO performs short writes can trigger a heap-based out-of-bounds write. Impact summary: This out-of- bounds write can cause memory corruption which typically results in a crash, leading to Denial of Service for an application. The line-buffering BIO filter (BIO_f_linebuffer) is not used by default in TLS/SSL data paths. In OpenSSL command-line applications, it is typically only pushed onto stdout/stderr on VMS systems. Third-party applications that explicitly use this filter with a BIO chain that can short-write and that write large, newline-free data influenced by an attacker would be affected. However, the circumstances where this could happen are unlikely to be under attacker control, and BIO_f_linebuffer is unlikely to be handling non-curated data controlled by an attacker. For that reason the issue was assessed as Low severity. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the BIO implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0, 1.1.1 and 1.0.2 are vulnerable to this issue. (CVE-2025-68160)

 - Issue summary: When using the low-level OCB API directly with AES-NI or other hardware-accelerated code paths, inputs whose length is not a multiple of 16 bytes can leave the final partial block unencrypted and unauthenticated. Impact summary: The trailing 1-15 bytes of a message may be exposed in cleartext on encryption and are not covered by the authentication tag, allowing an attacker to read or tamper with those bytes without detection. The low-level OCB encrypt and decrypt routines in the hardware-accelerated stream path process full 16-byte blocks but do not advance the input/output pointers. The subsequent tail-handling code then operates on the original base pointers, effectively reprocessing the beginning of the buffer while leaving the actual trailing bytes unprocessed. The authentication checksum also excludes the true tail bytes. However, typical OpenSSL consumers using EVP are not affected because the higher-level EVP and provider OCB implementations split inputs so that full blocks and trailing partial blocks are processed in separate calls, avoiding the problematic code path. Additionally, TLS does not use OCB ciphersuites. The vulnerability only affects applications that call the low-level CRYPTO_ocb128_encrypt() or CRYPTO_ocb128_decrypt() functions directly with non-block-aligned lengths in a single call on hardware- accelerated builds. For these reasons the issue was assessed as Low severity. The FIPS modules in 3.6, 3.5, 3.4, 3.3, 3.2, 3.1 and 3.0 are not affected by this issue, as OCB mode is not a FIPS- approved algorithm. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0 and 1.1.1 are vulnerable to this issue. OpenSSL 1.0.2 is not affected by this issue. (CVE-2025-69418)

 - Issue summary: Calling PKCS12_get_friendlyname() function on a maliciously crafted PKCS#12 file with a BMPString (UTF-16BE) friendly name containing non-ASCII BMP code point can trigger a one byte write before the allocated buffer. Impact summary: The out-of-bounds write can cause a memory corruption which can have various consequences including a Denial of Service. The OPENSSL_uni2utf8() function performs a two-pass conversion of a PKCS#12 BMPString (UTF-16BE) to UTF-8. In the second pass, when emitting UTF-8 bytes, the helper function bmp_to_utf8() incorrectly forwards the remaining UTF-16 source byte count as the destination buffer capacity to UTF8_putc(). For BMP code points above U+07FF, UTF-8 requires three bytes, but the forwarded capacity can be just two bytes. UTF8_putc() then returns -1, and this negative value is added to the output length without validation, causing the length to become negative. The subsequent trailing NUL byte is then written at a negative offset, causing write outside of heap allocated buffer.
 The vulnerability is reachable via the public PKCS12_get_friendlyname() API when parsing attacker- controlled PKCS#12 files. While PKCS12_parse() uses a different code path that avoids this issue, PKCS12_get_friendlyname() directly invokes the vulnerable function. Exploitation requires an attacker to provide a malicious PKCS#12 file to be parsed by the application and the attacker can just trigger a one zero byte write before the allocated buffer. For that reason the issue was assessed as Low severity according to our Security Policy. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the PKCS#12 implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0 and 1.1.1 are vulnerable to this issue. OpenSSL 1.0.2 is not affected by this issue.
 (CVE-2025-69419)

 - Issue summary: A type confusion vulnerability exists in the TimeStamp Response verification code where an ASN1_TYPE union member is accessed without first validating the type, causing an invalid or NULL pointer dereference when processing a malformed TimeStamp Response file. Impact summary: An application calling TS_RESP_verify_response() with a malformed TimeStamp Response can be caused to dereference an invalid or NULL pointer when reading, resulting in a Denial of Service. The functions ossl_ess_get_signing_cert() and ossl_ess_get_signing_cert_v2() access the signing cert attribute value without validating its type. When the type is not V_ASN1_SEQUENCE, this results in accessing invalid memory through the ASN1_TYPE union, causing a crash. Exploiting this vulnerability requires an attacker to provide a malformed TimeStamp Response to an application that verifies timestamp responses. The TimeStamp protocol (RFC 3161) is not widely used and the impact of the exploit is just a Denial of Service. For these reasons the issue was assessed as Low severity. The FIPS modules in 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the TimeStamp Response implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0 and 1.1.1 are vulnerable to this issue. OpenSSL 1.0.2 is not affected by this issue. (CVE-2025-69420)

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

The remote Redhat Enterprise Linux 9 host has packages installed that are affected by multiple vulnerabilities as referenced in the RHSA-2026:25239 advisory.

    OpenSSL is a toolkit that implements the Secure Sockets Layer (SSL) and Transport Layer Security (TLS)     protocols, as well as a full-strength general-purpose cryptography library.

    Security Fix(es):

    * openssl: OpenSSL: Heap buffer overflow due to signed integer overflow in Unicode output sizing     (CVE-2026-7383)

    * openssl: OpenSSL: Denial of Service due to heap out-of-bounds read in CMS password-based decryption     (CVE-2026-9076)

    * openssl: OpenSSL: Heap buffer over-read in ASN.1 decoding can lead to denial of service or information     disclosure. (CVE-2026-34180)

    * openssl: PKCS#12 Files with PBMAC1 Are Accepted with Short HMAC Keys (CVE-2026-34181)

    * openssl: CMS AuthEnvelopedData Processing May Accept Forged Messages (CVE-2026-34182)

    * openssl: Unbounded Memory Growth in the QUIC PATH_CHALLENGE Handler (CVE-2026-34183)

    * openssl: NULL pointer dereference in QUIC server initial packet handling (CVE-2026-42764)

    * openssl: Possible NULL Dereference in Password-Based CMS Decryption (CVE-2026-42766)

    * openssl: NULL Pointer Dereference in CRMF EncryptedValue Decryption (CVE-2026-42767)

    * openssl: Multi-RecipientInfo Bleichenbacher Oracle in CMS_decrypt() and PKCS7_decrypt() (CVE-2026-42768)

    * openssl: Trust-Anchor Substitution via cert/issuer Typo in CMP rootCaKeyUpdate (CVE-2026-42769)

    * openssl: FFC-DH Peer Validation Uses Attacker-Supplied q (CVE-2026-42770)

    * openssl: AES-OCB IV Ignored on EVP_Cipher() Path (CVE-2026-45445)

    * openssl: Incorrect Tag Processing for Empty Messages in AES-GCM-SIV and AES-SIV modes (CVE-2026-45446)

    * openssl: Heap Use-After-Free in OpenSSL PKCS7_verify() (CVE-2026-45447)

    For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and     other related information, refer to the CVE page(s) listed in the References section.

Tenable has extracted the preceding description block directly from the Red Hat Enterprise Linux security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

According to the versions of the openssl packages installed, the EulerOS Virtualization installation on the remote host is affected by the following vulnerabilities :

    Issue summary: A signed integer overflow when sizing the destination buffer for Unicode output in     ASN1_mbstring_ncopy() can lead to a heap buffer overflow.  Impact summary: A heap buffer overflow may lead     to a crash or possibly attacker controlled code execution or other undefined behaviour.  In     ASN1_mbstring_copy() and ASN1_mbstring_ncopy() the destination size for Unicode output is computed in a     signed int: by left shift of the input character count for BMPSTRING (UTF-16) and UNIVERSALSTRING     (UTF-32), and by summing per-character byte counts for UTF8STRING. The calculation overflows when the     input reaches around 2^30 characters. In the worst case (UNIVERSALSTRING at 2^30 characters) the size     wraps to zero, OPENSSL_malloc(1) is called, and the subsequent character copy writes several gigabytes     past the one-byte allocation.  X.509 certificate processing routes through ASN1_STRING_set_by_NID(), whose     DIRSTRING_TYPE mask excludes UNIVERSALSTRING and whose per-NID size limits cap the input length; no     network protocol or certificate-handling path in OpenSSL exercises the overflow. Triggering the bug     requires an application that calls ASN1_mbstring_copy() or ASN1_mbstring_ncopy() directly, or registers a     custom string type via ASN1_STRING_TABLE_add(), with attacker-controlled input on the order of half a     gigabyte or more. For these reasons this issue was assigned Low severity.  The FIPS modules in 4.0, 3.6,     3.5, 3.4 and 3.0 are not affected by this issue, as the affected code is outside the OpenSSL FIPS module     boundary.(CVE-2026-7383)

    Issue summary: Parsing a crafted DER-encoded ASN.1 structure with a primitive element whose content     exceeds 2 gigabytes in length may cause a heap buffer over-read on 64-bit Unix and Unix-like platforms.
    Impact summary: The heap buffer over-read may crash the application (Denial of Service) or to load into     the decoded ASN.1 object contents of memory beyond the end of the input buffer.  More typically such ASN.1     elements would instead be truncated.  An integer truncation in OpenSSL's ASN.1 decoder causes the content     length of an ASN.1 primitive element to be mishandled when it exceeds 2 gigabytes. In the worst case the     truncated length is treated as a request to scan the binary content for a terminating zero byte, possibly     causing OpenSSL to read either less than or beyond the end of the allocated buffer.  Applications that     pass attacker-supplied data to d2i_X509(), d2i_PKCS7(), or any other d2i_* decoding function are affected.
    OpenSSL's own command-line tools are not vulnerable, as data read through the BIO layer is checked before     it reaches the affected code. The issue only affects 64-bit Unix and Unix-like platforms; 32-bit platforms     and 64-bit Windows are not affected.  The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by     this issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-34180)

    Issue summary: When CMS password-based decryption (RFC 3211 / PWRI key unwrap) processes attacker-supplied     CMS data, an attacker-chosen stream-mode KEK cipher can trigger a heap out-of-bounds read in     kek_unwrap_key().  Impact summary: A heap buffer over-read may trigger a crash which leads to Denial of     Service for an application if the input buffer ends at a memory page boundary and the following page is     unmapped. There is no information disclosure as the over-read bytes are not revealed to the attacker.  The     key unwrapping function performs a check-byte test as specified in the RFC that reads 7 bytes from a heap     allocation that is based on the wrapped key length from the message. There is a minimum length check based     on the block length of the wrapping cipher. However the cipher is selected from an OID carried in the     attacker's PWRI keyEncryptionAlgorithm with no requirement that the cipher be a block cipher. When an     attacker selects a stream-mode cipher the guard will be ineffective and the allocated buffer containing     the unwrapped key can be too small to fit the check-bytes specified in the RFC and a buffer over-read can     happen.  Applications calling CMS_decrypt() or CMS_decrypt_set1_password() (equivalently openssl cms
    -decrypt -pwri_password ...) on untrusted CMS data are vulnerable to this issue. No password knowledge is     required: the over-read happens during the unwrap attempt before any authentication succeeds.  The over-     read is limited to a few bytes and is not written to output, so there is no information disclosure.
    Triggering a crash requires the allocation to border unmapped memory, which is unlikely with the normal     allocator.  The FIPS modules are not affected by this issue.(CVE-2026-9076)

     Issue summary: A specially crafted PKCS#7 or S/MIME signed message could trigger a use-after-free during     PKCS#7 signature verification.  Impact summary: A use-after-free may result in process crashes, heap     corruption, or potentially remote code execution.  When processing a PKCS#7 or S/MIME signed message, if     the SignedData digestAlgorithms field is present as an empty ASN.1 SET, OpenSSL may incorrectly free a     caller-owned BIO during PKCS7_verify(). A subsequent use of the BIO by the calling application results in     a use-after-free condition.  In the common case this occurs when the application later calls BIO_free() on     the BIO originally passed to PKCS7_verify(). Depending on allocator behavior and application-specific BIO     usage patterns, this may result in a crash or other memory corruption. In some application contexts this     may potentially be exploitable for remote code execution.  Applications that process PKCS#7 or S/MIME     signed messages using OpenSSL PKCS#7 APIs may be affected. Applications using the CMS APIs for this     processing are not affected.  The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this     issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-45447)

Tenable has extracted the preceding description block directly from the EulerOS Virtualization openssl security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

According to the versions of the shim package installed, the EulerOS Virtualization installation on the remote host is affected by the following vulnerabilities :

    Issue summary: Parsing a crafted DER-encoded ASN.1 structure with a primitive element whose content     exceeds 2 gigabytes in length may cause a heap buffer over-read on 64-bit Unix and Unix-like platforms.
    Impact summary: The heap buffer over-read may crash the application (Denial of Service) or to load into     the decoded ASN.1 object contents of memory beyond the end of the input buffer.  More typically such ASN.1     elements would instead be truncated.An integer truncation in OpenSSL's ASN.1 decoder causes the content     length of an ASN.1 primitive element to be mishandled when it exceeds 2 gigabytes. In the worst case the     truncated length is treated as a request to scan the binary content for a terminating zero byte, possibly     causing OpenSSL to read either less than or beyond the end of the allocated buffer.Applications that pass     attacker-supplied data to d2i_X509(), d2i_PKCS7(), or any other d2i_* decoding function are affected.
    OpenSSL's own command-line tools are not vulnerable, as data read through the BIO layer is checked before     it reaches the affected code. The issue only affects 64-bit Unix and Unix-like platforms; 32-bit platforms     and 64-bit Windows are not affected.The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by     this issue,as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-34180)

    Issue summary: A signed integer overflow when sizing the destination buffer for Unicode output in     ASN1_mbstring_ncopy() can lead to a heap buffer overflow.Impact summary: A heap buffer overflow may lead     to a crash or possibly attacker controlled code execution or other undefined behaviour.In     ASN1_mbstring_copy() and ASN1_mbstring_ncopy() the destination size for Unicode output is computed in a     signed int: by left shift of the input character count for BMPSTRING (UTF-16) and UNIVERSALSTRING     (UTF-32), and by summing per-character byte counts for UTF8STRING. The calculation overflows when the     input reaches around 2^30 characters. In the worst case (UNIVERSALSTRING at 2^30 characters) the size     wraps to zero, OPENSSL_malloc(1) is called, and the subsequent character copy writes several gigabytes     past the one-byte allocation.X.509 certificate processing routes through ASN1_STRING_set_by_NID(),whose     DIRSTRING_TYPE mask excludes UNIVERSALSTRING and whose per-NID size limits cap the input length; no     network protocol or certificate-handling path in OpenSSL exercises the overflow.Triggering the bug     requires an application that calls ASN1_mbstring_copy() or ASN1_mbstring_ncopy() directly, or registers a     custom string type via ASN1_STRING_TABLE_add(), with     attacker-controlled input on the order of half a gigabyte or more.For these reasons this issue was     assigned Low severity.The FIPS modules in 4.0, 3.6, 3.5, 3.4 and 3.0 are not affected by this issue, as     the affected code is outside the OpenSSL FIPS module     boundary.(CVE-2026-7383)

    Issue summary: A specially crafted PKCS#7 or S/MIME signed message could trigger a use-after-free during     PKCS#7 signature verification.Impact summary: A use-after-free may result in process crashes, heap     corruption, or potentially remote code execution.When processing a PKCS#7 or S/MIME signed message, if the     SignedData digestAlgorithms field is present as an empty ASN.1 SET, OpenSSL may incorrectly free a caller-     owned BIO during PKCS7_verify(). A subsequent use of the BIO by the calling application results in a use-     after-free condition.In the common case this occurs when the application later calls BIO_free() on the BIO     originally passed to PKCS7_verify(). Depending on allocator behavior and application-specific BIO usage     patterns, this may result in a crash or other memory corruption. In some application contexts this may     potentially be exploitable for remote code execution.Applications that process PKCS#7 or S/MIME signed     messages using OpenSSL PKCS#7 APIs may be affected. Applications using the CMS APIs for this     processing are not affected.The FIPS modules in 4.0, 3.6, 3.5, 3.4, and 3.0 are not affected by this     issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-45447)

Tenable has extracted the preceding description block directly from the EulerOS Virtualization shim security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

ID	名称	产品	系列	发布时间	最近更新时间	严重程度
321595	SUSE SLES15 Security Update : openssl-1_1 (SUSE-SU-2026:2405-1)	Nessus	SuSE Local Security Checks	2026/6/20	2026/7/3	high
322008	Amazon Linux 2 : edk2, --advisory ALAS2-2026-3363 (ALAS-2026-3363)	Nessus	Amazon Linux Local Security Checks	2026/6/22	2026/7/3	high
322900	SUSE SLES15: libopenssl-1_1-devel / libopenssl-1_1-devel-32bit / libopenssl1_1 / etc (SUSE-SU-2026:2614-1)	Nessus	SuSE Local Security Checks	2026/6/26	2026/7/2	high
329278	MiracleLinux 9 : openssl-3.5.5-4.el9_8.ML.1 (AXSA:2026-1339:14)	Nessus	Miracle Linux Local Security Checks	2026/7/24	2026/7/24	critical
330462	Oracle Linux 10 : openssl (ELSA-2026-25237)	Nessus	Oracle Linux Local Security Checks	2026/7/28	2026/7/28	critical
346764	EulerOS 2.0 SP15 : openssl (EulerOS-SA-2026-3787)	Nessus	Huawei Local Security Checks	2026/9/17	2026/9/17	critical
321398	Photon OS 4.0: Openssl PHSA-2026-4.0-1031	Nessus	PhotonOS Local Security Checks	2026/6/17	2026/6/17	critical
332414	Photon OS 5.0: Openssl PHSA-2026-5.0-92-0874	Nessus	PhotonOS Local Security Checks	2026/8/5	2026/8/8	high
321593	SUSE SLES15 Security Update : openssl-3 (SUSE-SU-2026:2397-1)	Nessus	SuSE Local Security Checks	2026/6/20	2026/7/3	high
320141	OpenSSL 1.0.2 < 1.0.2zq Multiple Vulnerabilities	Nessus	Web Servers	2026/6/9	2026/8/27	high
321598	SUSE SLES12 Security Update : openssl-1_0_0 (SUSE-SU-2026:2396-1)	Nessus	SuSE Local Security Checks	2026/6/20	2026/6/20	high
343631	EulerOS 2.0 SP12 : shim (EulerOS-SA-2026-3386)	Nessus	Huawei Local Security Checks	2026/9/8	2026/9/8	high
343679	EulerOS 2.0 SP12 : shim (EulerOS-SA-2026-3311)	Nessus	Huawei Local Security Checks	2026/9/8	2026/9/8	high
343598	NewStart CGSL MAIN 7.02 : tongsuo Multiple Vulnerabilities (NS-SA-2026-0106)	Nessus	NewStart CGSL Local Security Checks	2026/9/8	2026/9/8	high
320634	RHEL 9 : openssl (RHSA-2026:25239)	Nessus	Red Hat Local Security Checks	2026/6/11	2026/6/12	critical
348095	EulerOS Virtualization 2.12.1 : openssl (EulerOS-SA-2026-3602)	Nessus	Huawei Local Security Checks	2026/9/18	2026/9/18	high
348539	EulerOS Virtualization 2.10.0 : shim (EulerOS-SA-2026-3889)	Nessus	Huawei Local Security Checks	2026/9/21	2026/9/21	high

检测

插件搜索

high

high

high

critical

critical

critical

critical

high

high

high

high

high

high

high

critical

high

high