Unity Linux 20.1050a Security Update: kernel (UTSA-2026-100532)

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

include('compat.inc');

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

  script_cve_id("CVE-2026-64374");

  script_name(english:"Unity Linux 20.1050a Security Update: kernel (UTSA-2026-100532)");

  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-2026-100532 advisory.

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

    sched/rt: Have RT_PUSH_IPI be default off for non PREEMPT_RT

    RT migration is done aggressively. When a CPU schedules out a high
    priority RT task for a lower priority task, it will look to see if there's
    any RT tasks that are waiting to run on another CPU that is of higher
    priority than the task this CPU is about to run. If it finds one, it will
    pull that task over to the CPU and allow it to run there instead.

    Normally, this pulling is done by looking at the RT overloaded mask (rto)
    which contains all the CPUs in the scheduler domain with RT tasks that are
    waiting to run due to a higher priority RT task currently running on their
    CPU. The CPU that is about to schedule a lower priority task will grab the
    rq lock of the overloaded CPU and move the RT task from that CPU's runqueue
    to the local one and schedule the higher priority RT task.

    This caused issues when a lot of CPUs would schedule a lower priority task
    at the same time. They would all try to grab the same runqueue lock of
    the CPU with the overloaded RT tasks. Only the first CPU that got in will
    get that task. All the others would wait until they got the runqueue lock
    and see there's nothing to pull and do nothing. On systems with lots of
    CPUs, this caused a large latency (up to 500us) which is beyond what
    PREEMPT_RT is to allow.

    The solution to that was to create an RT_PUSH_IPI logic. When any CPU
    wanted to pull a task, instead of grabbing the runqueue lock of the
    overloaded CPU, it would start by sending an IPI to the overloaded CPU,
    and that IPI handler would have the CPU with the waiting RT task do a push
    instead. Then that handler would send an IPI to the next CPU with
    overloaded RT tasks, and so on. Note, after the first CPU starts this
    process, if another CPU wanted to do a pull, it would see that the process
    has already begun and would only increment a counter to have the IPIs
    continue again.

    The RT_PUSH_IPI solved the latency problem with PREEMPT_RT but could cause
    a new issue with non PREEMPT_RT. Namely, softirqs run in a threaded
    context on PREEMPT_RT but they can run in an interrupt context in non-RT.

    If an IPI lands on a CPU that has just woken up multiple RT tasks and the
    current CPU is running a non RT or a low priority RT task, instead of
    doing a push, it would simply do a schedule on that CPU. But if a softirq
    was also executing on this CPU, the schedule would need to wait until the
    softirq finished. Until then, the CPU would still be considered overloaded
    as there are RT tasks still waiting to run on it.

    A live lock occurred on a workload that was doing heavy networking traffic
    on a large machine where the softirqs would run 500us out of 750us. And it
    would also be waking up RT tasks, causing the RT pull logic to be
    constantly executed.

    When a softirq triggered on a CPU with RT tasks queued but not running
    yet, and the other CPUs would see this CPU as being overloaded, they would
    send an IPI over to it. The CPU would notice that the waiting RT tasks are
    of higher priority than the currently running task and simply schedule
    that CPU instead. But because the softirq was executing, before it could
    schedule, it would receive another IPI to do the same. The amount of IPIs
    would slow down the currently running softirq so much that before it could
    return back to task context, it would execute another softirq never
    allowing the CPU to schedule. This live locked that CPU.

    As RT_PUSH_IPI was created to help PREEMPT_RT, make it default off if
    PREEMPT_RT is not enabled.

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-2026-100532
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?06f670a2");
  # https://lore.kernel.org/linux-cve-announce/2026072523-CVE-2026-64374-a14e@gregkh
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?73f91d5a");
  script_set_attribute(attribute:"see_also", value:"https://nvd.nist.gov/vuln/detail/CVE-2026-64374");
  script_set_attribute(attribute:"solution", value:
"Update the affected kernel package.");
  script_set_cvss_base_vector("CVSS2#AV:N/AC:L/Au:N/C:N/I:N/A:C");
  script_set_cvss_temporal_vector("CVSS2#E:U/RL:OF/RC:C");
  script_set_cvss3_base_vector("CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H");
  script_set_cvss3_temporal_vector("CVSS:3.0/E:U/RL:O/RC:C");
  script_set_attribute(attribute:"cvss_score_source", value:"CVE-2026-64374");

  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:"2026/07/23");
  script_set_attribute(attribute:"patch_publication_date", value:"2026/08/13");
  script_set_attribute(attribute:"plugin_publication_date", value:"2026/08/17");

  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) 2026 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.1050a([^0-9]|$)", string:os_version)) audit(AUDIT_OS_NOT, 'UOS Server 20.1050a', '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 && 'x86_64' >!< cpu) audit(AUDIT_LOCAL_CHECKS_NOT_IMPLEMENTED, 'UOS Server', cpu);


var constraints = [
  {
    'release': '20',
    'sp': '1050a',
    'pkgs': [
      {'reference':'kernel-5.10.0-27.18.uelc20', 'sp':'1050a', 'cpu':'aarch64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'kernel-5.10.0-27.18.uelc20', 'sp':'1050a', 'cpu':'amd64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'kernel-5.10.0-27.18.uelc20', 'sp':'1050a', 'cpu':'x86_64', 'rpm_spec_vers_cmp':TRUE}
    ]
  }
];

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

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


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