EulerOS 2.0 SP15 : EDK2 (EulerOS-SA-2026-3894)

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

include('compat.inc');

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

  script_cve_id(
    "CVE-2026-7383",
    "CVE-2026-9076",
    "CVE-2026-28387",
    "CVE-2026-28388",
    "CVE-2026-28389",
    "CVE-2026-28390",
    "CVE-2026-31789",
    "CVE-2026-34180",
    "CVE-2026-34182",
    "CVE-2026-42766",
    "CVE-2026-42767",
    "CVE-2026-42768",
    "CVE-2026-42770",
    "CVE-2026-45445"
  );

  script_name(english:"EulerOS 2.0 SP15 : EDK2 (EulerOS-SA-2026-3894)");

  script_set_attribute(attribute:"synopsis", value:
"The remote EulerOS host is missing multiple security updates.");
  script_set_attribute(attribute:"description", value:
"According to the versions of the EDK2 package installed, the EulerOS installation on the remote host is affected by the
following vulnerabilities :

    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: 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)

    Issue summary: Converting an excessively large OCTET STRING value to_x000D_
    a hexadecimal string leads to a heap buffer overflow on 32 bit platforms._x000D_
    _x000D_
    Impact summary: A heap buffer overflow may lead to a crash or possibly_x000D_
    an attacker controlled code execution or other undefined behavior._x000D_
    _x000D_
    If an attacker can supply a crafted X.509 certificate with an excessively_x000D_
    large OCTET STRING value in extensions such as the Subject Key Identifier_x000D_
    (SKID) or Authority Key Identifier (AKID) which are being converted to hex,_x000D_
    the size of the buffer needed for the result is calculated as multiplication_x000D_
    of the input length by 3. On 32 bit platforms, this multiplication may overflow_x000D_
    resulting in the allocation of a smaller buffer and a heap buffer overflow._x000D_
    _x000D_
    Applications and services that print or log contents of untrusted X.509_x000D_
    certificates are vulnerable to this issue. As the certificates would have_x000D_
    to have sizes of over 1 Gigabyte, printing or logging such certificates_x000D_
    is a fairly unlikely operation and only 32 bit platforms are affected,_x000D_
    this issue was assigned Low severity._x000D_
    _x000D_
    The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this_x000D_
    issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-31789)

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

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

    Issue summary: The CMS_decrypt and PKCS7_decrypt functions are vulnerable to_x000D_
    Bleichenbacher-style attack when an attacker is able to provide the CMS or_x000D_
    S/MIME messages and observe the error code and/or decryption output._x000D_
    _x000D_
    Impact summary: The Bleichenbacher-style attack allows an attacker to use the_x000D_
    victim's vulnerable application as a way to decrypt or sign messages with the_x000D_
    victim's private RSA key._x000D_
    _x000D_
    The attack is possible in 2 variants._x000D_
    _x000D_
    1. The decryption API (CMS_decrypt(), PKCS7_decrypt()) is used without_x000D_
    providing the recipient certificate. In this case OpenSSL iterates over every_x000D_
    KeyTransRecipientInfo (KTRI) without stopping at the first success._x000D_
    _x000D_
    An attacker who authors a message with two KTRI entries - the first one_x000D_
    wrapping a real CEK under the victim's public key, the second with an_x000D_
    arbitrary probe ciphertext - obtains opportunity to iterate the 2nd KTRI to_x000D_
    get a valid PKCS#1 v1.5 padding if the error code of the application is_x000D_
    available._x000D_
    _x000D_
    That is a Bleichenbacher oracle (Bleichenbacher, CRYPTO '98): an_x000D_
    adaptive-chosen-ciphertext side channel from which the attacker decrypts any_x000D_
    RSA ciphertext to the victim's key or forges any PKCS#1 v1.5 signature under_x000D_
    it._x000D_
    _x000D_
    2. When the decryption API (CMS_decrypt(), PKCS7_decrypt()) is provided with_x000D_
    the recipient certificate, and the recipient is not found, a random_x000D_
    key is substituted._x000D_
    _x000D_
    An attacker who authors a message and is able to compare both error code and_x000D_
    the result of the decryption, can mount a Bleichenbacher oracle._x000D_
    _x000D_
    We are not aware of any applications that provide a remote attacker_x000D_
    an opportunity to mount an attack described in these scenarios. We consider_x000D_
    the existence of such application very unlikely, and for this reason this_x000D_
    CVE has been evaluated as Low severity._x000D_
    _x000D_
    To avoid these attacks, when RSA PKCS#1 v1.5 Key Transport is in use, the_x000D_
    invoked EVP_PKEY_decrypt() will use the implicit rejection mechanism described_x000D_
    in draft-irtf-cfrg-rsa-guidance. In previous OpenSSL releases the implicit_x000D_
    rejection was explicitly disabled._x000D_
    _x000D_
    The implicit rejection mechanism always returns a plaintext value,_x000D_
    the symmetric key. This result is deterministic for the ciphertext and the_x000D_
    private key.  The length of the decryption result can happen to match the_x000D_
    length of the key of the symmetric cipher that was used for the content_x000D_
    encryption. When a certificate is not provided, the last RecipientInfo_x000D_
    producing a key that looks valid will be used. It may cause getting garbage_x000D_
    content on decryption. As a proper way to deal with this a recipient_x000D_
    certificate has to be provided to identify the particular RecipientInfo for_x000D_
    decryption._x000D_
    _x000D_
    The FIPS modules in 4.0, 3.6, 3.5, and 3.4 are not affected by this issue, as_x000D_
    CMS and S/MIME processing happens outside the OpenSSL FIPS module boundary.(CVE-2026-42768)

    Issue summary: When a delta CRL that contains a Delta CRL Indicator extension_x000D_
    is processed a NULL pointer dereference might happen if the required CRL_x000D_
    Number extension is missing._x000D_
    _x000D_
    Impact summary: A NULL pointer dereference can trigger a crash which_x000D_
    leads to a Denial of Service for an application._x000D_
    _x000D_
    When CRL processing and delta CRL processing is enabled during X.509_x000D_
    certificate verification, the delta CRL processing does not check_x000D_
    whether the CRL Number extension is NULL before dereferencing it._x000D_
    When a malformed delta CRL file is being processed, this parameter_x000D_
    can be NULL, causing a NULL pointer dereference._x000D_
    _x000D_
    Exploiting this issue requires the X509_V_FLAG_USE_DELTAS flag to be enabled in_x000D_
    the verification context, the certificate being verified to contain a_x000D_
    freshestCRL extension or the base CRL to have the EXFLAG_FRESHEST flag set, and_x000D_
    an attacker to provide a malformed CRL to an application that processes it._x000D_
    _x000D_
    The vulnerability is limited to Denial of Service and cannot be escalated to_x000D_
    achieve code execution or memory disclosure. For that reason the issue was_x000D_
    assessed as Low severity according to our Security Policy._x000D_
    _x000D_
    The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue,_x000D_
    as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-28388)

    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: During processing of a crafted CMS EnvelopedData message_x000D_
    with KeyTransportRecipientInfo a NULL pointer dereference can happen._x000D_
    _x000D_
    Impact summary: Applications that process attacker-controlled CMS data may_x000D_
    crash before authentication or cryptographic operations occur resulting in_x000D_
    Denial of Service._x000D_
    _x000D_
    When a CMS EnvelopedData message that uses KeyTransportRecipientInfo with_x000D_
    RSA-OAEP encryption is processed, the optional parameters field of_x000D_
    RSA-OAEP SourceFunc algorithm identifier is examined without checking_x000D_
    for its presence. This results in a NULL pointer dereference if the field_x000D_
    is missing._x000D_
    _x000D_
    Applications and services that call CMS_decrypt() on untrusted input_x000D_
    (e.g., S/MIME processing or CMS-based protocols) are vulnerable._x000D_
    _x000D_
    The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this_x000D_
    issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-28390)

    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: 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: During processing of a crafted CMS EnvelopedData message_x000D_
    with KeyAgreeRecipientInfo a NULL pointer dereference can happen._x000D_
    _x000D_
    Impact summary: Applications that process attacker-controlled CMS data may_x000D_
    crash before authentication or cryptographic operations occur resulting in_x000D_
    Denial of Service._x000D_
    _x000D_
    When a CMS EnvelopedData message that uses KeyAgreeRecipientInfo is_x000D_
    processed, the optional parameters field of KeyEncryptionAlgorithmIdentifier_x000D_
    is examined without checking for its presence. This results in a NULL_x000D_
    pointer dereference if the field is missing._x000D_
    _x000D_
    Applications and services that call CMS_decrypt() on untrusted input_x000D_
    (e.g., S/MIME processing or CMS-based protocols) are vulnerable._x000D_
    _x000D_
    The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this_x000D_
    issue, as the affected code is outside the OpenSSL FIPS module boundary.(CVE-2026-28389)

    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)

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

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version
number.");
  # https://developer.huaweicloud.com/ict/en/site-euleros/euleros/security-advisories/EulerOS-SA-2026-3894
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?70660089");
  script_set_attribute(attribute:"solution", value:
"Update the affected EDK2 packages.");
  script_set_cvss_base_vector("CVSS2#AV:N/AC:L/Au:N/C:C/I:C/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:H/I:H/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-31789");

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

  script_set_attribute(attribute:"vuln_publication_date", value:"2024/04/09");
  script_set_attribute(attribute:"patch_publication_date", value:"2026/10/08");
  script_set_attribute(attribute:"plugin_publication_date", value:"2026/10/08");

  script_set_attribute(attribute:"plugin_type", value:"local");
  script_set_attribute(attribute:"cpe", value:"p-cpe:/a:huawei:euleros:edk2-ovmf");
  script_set_attribute(attribute:"cpe", value:"cpe:/o:huawei:euleros:2.0");
  script_set_attribute(attribute:"generated_plugin", value:"current");
  script_end_attributes();

  script_category(ACT_GATHER_INFO);
  script_family(english:"Huawei 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_info.nasl");
  script_require_keys("Host/local_checks_enabled", "Host/cpu", "Host/EulerOS/release", "Host/EulerOS/rpm-list", "Host/EulerOS/sp");
  script_exclude_keys("Host/EulerOS/uvp_version");

  exit(0);
}

include("rpm.inc");

if (!get_kb_item("Host/local_checks_enabled")) audit(AUDIT_LOCAL_CHECKS_NOT_ENABLED);

var _release = get_kb_item("Host/EulerOS/release");
if (isnull(_release) || _release !~ "^EulerOS") audit(AUDIT_OS_NOT, "EulerOS");
var uvp = get_kb_item("Host/EulerOS/uvp_version");
if (_release !~ "^EulerOS release 2\.0(\D|$)") audit(AUDIT_OS_NOT, "EulerOS 2.0 SP15");

var sp = get_kb_item("Host/EulerOS/sp");
if (isnull(sp) || sp !~ "^(15)$") audit(AUDIT_OS_NOT, "EulerOS 2.0 SP15");

if (!empty_or_null(uvp)) audit(AUDIT_OS_NOT, "EulerOS 2.0 SP15", "EulerOS UVP " + uvp);

if (!get_kb_item("Host/EulerOS/rpm-list")) audit(AUDIT_PACKAGE_LIST_MISSING);

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

var flag = 0;

var pkgs = [
  "edk2-ovmf-202308-17.h21510.43.eulerosv2r15"
];

foreach (var pkg in pkgs)
  if (rpm_check(release:"EulerOS-2.0", sp:"15", reference:pkg)) 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, "EDK2");
}