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

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

include('compat.inc');

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

  script_cve_id("CVE-2026-46116");

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

  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-099013 advisory.

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

    xfrm: defensively unhash xfrm_state lists in __xfrm_state_delete

    KASAN reproduces a slab-use-after-free in __xfrm_state_delete()'s
    hlist_del_rcu calls under syzkaller load on linux-6.12.y stable
    (reproduced on 6.12.47, also reachable via the same code path on
    torvalds/master and on the ipsec tree). Nine unique signatures cluster
    in the xfrm_state lifecycle, the load-bearing one being:

      BUG: KASAN: slab-use-after-free in __hlist_del include/linux/list.h:990 [inline]
      BUG: KASAN: slab-use-after-free in hlist_del_rcu include/linux/rculist.h:516 [inline]
      BUG: KASAN: slab-use-after-free in __xfrm_state_delete net/xfrm/xfrm_state.c
      Write of size 8 at addr ffff8881198bcb70 by task kworker/u8:9/435

      Workqueue: netns cleanup_net
      Call Trace:
       __hlist_del / hlist_del_rcu
       __xfrm_state_delete
       xfrm_state_delete
       xfrm_state_flush
       xfrm_state_fini
       ops_exit_list
       cleanup_net

    The other observed signatures hit the same slab object from
    __xfrm_state_lookup, xfrm_alloc_spi, __xfrm_state_insert and an OOB
    write variant of __xfrm_state_delete, all on the byseq/byspi
    hash chains.

    __xfrm_state_delete() guards its byseq and byspi unhashes with
    value-based predicates:

            if (x->km.seq)
                    hlist_del_rcu(&x->byseq);
            if (x->id.spi)
                    hlist_del_rcu(&x->byspi);

    while everywhere else in the file (e.g. state_cache, state_cache_input)
    the safer hlist_unhashed() check is used. xfrm_alloc_spi() sets
    x->id.spi = newspi inside xfrm_state_lock and then immediately inserts
    into byspi, but a path that observes x->id.spi != 0 outside of
    xfrm_state_lock can still skip-or-hit the byspi unhash inconsistently
    with whether x is actually on the list. The same holds for x->km.seq
    versus byseq, and the bydst/bysrc unhashes have no predicate at all,
    so a second __xfrm_state_delete() on the same object writes through
    LIST_POISON pprev.

    The defensive change here:

      - Use hlist_del_init_rcu() instead of hlist_del_rcu() on bydst,
        bysrc, byseq and byspi so a second deletion is a no-op rather
        than a write through LIST_POISON pprev. The byseq/byspi nodes
        are already initialised in xfrm_state_alloc().
      - Test hlist_unhashed() rather than the value predicate for
        byseq/byspi, so the unhash decision tracks list state rather than
        mutable scalar fields.

    Empirical verification: applied this patch on top of v6.12.47, rebuilt,
    and re-ran the same syzkaller harness for 1h16m on a previously-crashy
    configuration that produced ~100 hits each of slab-use-after-free
    Read in xfrm_alloc_spi / Read in __xfrm_state_lookup / Write in
    __xfrm_state_delete. After the patch, 7.1M execs across 32 VMs at
    ~1550 exec/sec produced zero xfrm_state UAF/OOB hits. /proc/slabinfo
    confirms the xfrm_state slab is actively allocated and freed during
    the run (~143 KiB resident), so the fuzzer is still exercising those
    code paths -- they just no longer crash.

    Reproduction:

      - Linux 6.12.47 x86_64 + KASAN_GENERIC + KASAN_INLINE + KCOV
      - syzkaller @ 746545b8b1e4c3a128db8652b340d3df90ce61db
      - 32 QEMU/KVM VMs x 2 vCPU on AWS c5.metal bare metal
      - 9 unique signatures collected in ~9h, all within xfrm_state
        lifecycle

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-099013
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?98abf339");
  # https://lore.kernel.org/linux-cve-announce/2026052814-CVE-2026-46116-73b8@gregkh
  script_set_attribute(attribute:"see_also", value:"http://www.nessus.org/u?d1b5303a");
  script_set_attribute(attribute:"see_also", value:"https://nvd.nist.gov/vuln/detail/CVE-2026-46116");
  script_set_attribute(attribute:"solution", value:
"Update the affected kernel package.");
  script_set_cvss_base_vector("CVSS2#AV:L/AC:L/Au:S/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:L/AC:H/PR:L/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-46116");

  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/05/26");
  script_set_attribute(attribute:"patch_publication_date", value:"2026/08/10");
  script_set_attribute(attribute:"plugin_publication_date", value:"2026/08/26");

  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 && 'loongarch64' >!< cpu && 'x86_64' >!< cpu) audit(AUDIT_LOCAL_CHECKS_NOT_IMPLEMENTED, 'UOS Server', cpu);


var constraints = [
  {
    'release': '20',
    'sp': '1050a',
    'pkgs': [
      {'reference':'kernel-4.19.0-91.82.132.24.uelc20', 'sp':'1050a', 'cpu':'aarch64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'kernel-4.19.0-91.82.132.24.uelc20', 'sp':'1050a', 'cpu':'amd64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'kernel-4.19.0-91.82.132.24.uelc20', 'sp':'1050a', 'cpu':'loongarch64', 'rpm_spec_vers_cmp':TRUE},
      {'reference':'kernel-4.19.0-91.82.132.24.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_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');
}