Unity Linux 20.1070a Security Update: kernel (UTSA-2025-990248)

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

include('compat.inc');

if (description)
{
  script_id(272442);
  script_version("1.1");
  script_set_attribute(attribute:"plugin_modification_date", value:"2025/11/05");

  script_cve_id("CVE-2024-39488");

  script_name(english:"Unity Linux 20.1070a Security Update: kernel (UTSA-2025-990248)");

  script_set_attribute(attribute:"synopsis", value:
"The Unity Linux host is missing one or more security updates.");
  script_set_attribute(attribute:"description", value:
"The Unity Linux 20 host has a package installed that is affected by a vulnerability as referenced in the
UTSA-2025-990248 advisory.

    In the Linux kernel, the following vulnerability has been resolved:

    arm64: asm-bug: Add .align 2 to the end of __BUG_ENTRY

    When CONFIG_DEBUG_BUGVERBOSE=n, we fail to add necessary padding bytes
    to bug_table entries, and as a result the last entry in a bug table will
    be ignored, potentially leading to an unexpected panic(). All prior
    entries in the table will be handled correctly.

    The arm64 ABI requires that struct fields of up to 8 bytes are
    naturally-aligned, with padding added within a struct such that struct
    are suitably aligned within arrays.

    When CONFIG_DEBUG_BUGVERPOSE=y, the layout of a bug_entry is:

            struct bug_entry {
                    signed int      bug_addr_disp;  // 4 bytes
                    signed int      file_disp;      // 4 bytes
                    unsigned short  line;           // 2 bytes
                    unsigned short  flags;          // 2 bytes
            }

    ... with 12 bytes total, requiring 4-byte alignment.

    When CONFIG_DEBUG_BUGVERBOSE=n, the layout of a bug_entry is:

            struct bug_entry {
                    signed int      bug_addr_disp;  // 4 bytes
                    unsigned short  flags;          // 2 bytes
                    < implicit padding >            // 2 bytes
            }

    ... with 8 bytes total, with 6 bytes of data and 2 bytes of trailing
    padding, requiring 4-byte alginment.

    When we create a bug_entry in assembly, we align the start of the entry
    to 4 bytes, which implicitly handles padding for any prior entries.
    However, we do not align the end of the entry, and so when
    CONFIG_DEBUG_BUGVERBOSE=n, the final entry lacks the trailing padding
    bytes.

    For the main kernel image this is not a problem as find_bug() doesn't
    depend on the trailing padding bytes when searching for entries:

            for (bug = __start___bug_table; bug < __stop___bug_table; ++bug)
                    if (bugaddr == bug_addr(bug))
                            return bug;

    However for modules, module_bug_finalize() depends on the trailing
    bytes when calculating the number of entries:

            mod->num_bugs = sechdrs[i].sh_size / sizeof(struct bug_entry);

    ... and as the last bug_entry lacks the necessary padding bytes, this entry
    will not be counted, e.g. in the case of a single entry:

            sechdrs[i].sh_size == 6
            sizeof(struct bug_entry) == 8;

            sechdrs[i].sh_size / sizeof(struct bug_entry) == 0;

    Consequently module_find_bug() will miss the last bug_entry when it does:

            for (i = 0; i < mod->num_bugs; ++i, ++bug)
                    if (bugaddr == bug_addr(bug))
                            goto out;

    ... which can lead to a kenrel panic due to an unhandled bug.

    This can be demonstrated with the following module:

            static int __init buginit(void)
            {
                    WARN(1, hello\n);
                    return 0;
            }

            static void __exit bugexit(void)
            {
            }

            module_init(buginit);
            module_exit(bugexit);
            MODULE_LICENSE(GPL);

    ... which will trigger a kernel panic when loaded:

            ------------[ cut here ]------------
            hello
            Unexpected kernel BRK exception at EL1
            Internal error: BRK handler: 00000000f2000800 [#1] PREEMPT SMP
            Modules linked in: hello(O+)
            CPU: 0 PID: 50 Comm: insmod Tainted: G           O       6.9.1 #8
            Hardware name: linux,dummy-virt (DT)
            pstate: 60400005 (nZCv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--)
            pc : buginit+0x18/0x1000 [hello]
            lr : buginit+0x18/0x1000 [hello]
            sp : ffff800080533ae0
            x29: ffff800080533ae0 x28: 0000000000000000 x27: 0000000000000000
            x26: ffffaba8c4e70510 x25: ffff800080533c30 x24: ffffaba8c4a28a58
            x23: 0000000000000000 x22: 0000000000000000 x21: ffff3947c0eab3c0
            x20: ffffaba8c4e3f000 x19: ffffaba846464000 x18: 0000000000000006
            x17: 0000000000000000 x16: ffffaba8c2492834 x15: 0720072007200720
            x14: 0720072007200720 x13: ffffaba8c49b27c8 x12: 0000000000000312
            x11: 0000000000000106 x10: ffffaba8c4a0a7c8 x9 : ffffaba8c49b27c8
            x8 : 00000000ffffefff x7 : ffffaba8c4a0a7c8 x6 : 80000000fffff000
            x5 : 0000000000000107 x4 : 0000000000000000 x3 : 0000000000000000
            x2 : 0000000000000000 x1 : 0000000000000000 x0 : ffff3947c0eab3c0
            Call trace:
             buginit+0x18/0x1000 [hello]
             do_one_initcall+0x80/0x1c8
             do_init_module+0x60/0x218
             load_module+0x1ba4/0x1d70
             __do_sys_init_module+0x198/0x1d0
             __arm64_sys_init_module+0x1c/0x28
             invoke_syscall+0x48/0x114
             el0_svc
    ---truncated---

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

Note that Nessus has not tested for this issue but has instead relied only on the application's self-reported version
number.");
  # https://src.uniontech.com/#/security_advisory_detail?utsa_id=UTSA-2025-990248
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?8ca4a94c");
  # https://lore.kernel.org/linux-cve-announce/2024071013-CVE-2024-39488-f796@gregkh
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?e22e35dd");
  script_set_attribute(attribute:"see_also", value:"https://nvd.nist.gov/vuln/detail/CVE-2024-39488");
  script_set_attribute(attribute:"solution", value:
"Update the affected kernel package.");
  script_set_cvss_base_vector("CVSS2#AV:L/AC:L/Au:S/C:N/I:N/A:C");
  script_set_cvss_temporal_vector("CVSS2#E:U/RL:OF/RC:C");
  script_set_cvss3_base_vector("CVSS:3.0/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H");
  script_set_cvss3_temporal_vector("CVSS:3.0/E:U/RL:O/RC:C");
  script_set_attribute(attribute:"cvss_score_source", value:"CVE-2024-39488");

  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/06/27");
  script_set_attribute(attribute:"patch_publication_date", value:"2025/11/05");
  script_set_attribute(attribute:"plugin_publication_date", value:"2025/11/05");

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

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

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

  script_dependencies("ssh_get_info2.nasl");
  script_require_keys("Host/local_checks_enabled", "Host/UOS-Server/release", "Host/UOS-Server/rpm-list", "Host/cpu");

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

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

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

var cpu = get_kb_item('Host/cpu');
if (isnull(cpu)) audit(AUDIT_UNKNOWN_ARCH);
if ('aarch64' >!< cpu && 'amd64' >!< cpu && 'loongarch64' >!< cpu && 'x86_64' >!< cpu) audit(AUDIT_LOCAL_CHECKS_NOT_IMPLEMENTED, 'UOS Server', cpu);


var constraints = [
  {
    'release': '20',
    'sp': '1070a',
    'pkgs': [
      {'reference':'kernel-5.10.0-79.4.2', 'sp':'1070a', 'cpu':'aarch64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'kernel-5.10.0-79.4.2', 'sp':'1070a', 'cpu':'amd64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'kernel-5.10.0-79.4.2', 'sp':'1070a', 'cpu':'loongarch64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'kernel-5.10.0-79.4.2', 'sp':'1070a', 'cpu':'x86_64', 'rpm_spec_vers_cmp':TRUE}
    ]
  }
];

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

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


if (flag)
{
  security_report_v4(
      port       : 0,
      severity   : SECURITY_WARNING,
      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, 'kernel');
}