runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be truncated. An attacker must have the ability to start containers using some kind of custom volume configuration. Containers using user namespaces are still affected, but the scope of places an attacker can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3. Some workarounds are available. Using user namespaces restricts this attack fairly significantly such that the attacker can only create inodes in directories that the remapped root user/group has write access to. Unless the root user is remapped to an actual user on the host (such as with rootless containers that don't use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes in world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict the scope if a specific label is applied to the runc runtime, though neither the extent to which the standard existing policies block this attack nor what exact policies are needed to sufficiently restrict this attack have been thoroughly tested.

The remote SUSE Linux SLES12 host has a package installed that is affected by a vulnerability as referenced in the SUSE- SU-2025:1374-1 advisory.

    - CVE-2024-45310: Fixed unintentional creation of empty files/directories on host (bsc#1230092)

    Other fixes:

    - Update to runc v1.2.6.

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

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

The version of cri-tools / moby-runc / runc installed on the remote Azure Linux 3.0 host is prior to tested version. It is, therefore, affected by a vulnerability as referenced in the CVE-2024-45310 advisory.

  - runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy May restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3. Some     workarounds are available. Using user namespaces restricts this attack fairly significantly such that the     attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actual user on the host (such as with rootless containers that     don't use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes     in world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

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

The version of cri-tools / moby-runc / runc installed on the remote CBL Mariner 2.0 host is prior to tested version. It is, therefore, affected by a vulnerability as referenced in the CVE-2024-45310 advisory.

  - runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy May restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3. Some     workarounds are available. Using user namespaces restricts this attack fairly significantly such that the     attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actual user on the host (such as with rootless containers that     don't use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes     in world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

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

It is, therefore, affected by a vulnerability as referenced in the ALAS2023-2025-886 advisory.

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3.

    Some workarounds are available. Using user namespaces restricts this attack fairly significantly such that     the attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actualuser on the host (such as with rootless containers that don't     use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes in     world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

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

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

The version of ecs-init installed on the remote host is prior to 1.89.1-1. It is, therefore, affected by a vulnerability as referenced in the ALAS2ECS-2025-050 advisory.

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3.

    Some workarounds are available. Using user namespaces restricts this attack fairly significantly such that     the attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actualuser on the host (such as with rootless containers that don't     use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes in     world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

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

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

The Linux/Unix host has one or more packages installed that are impacted by a vulnerability without a vendor supplied patch available.

  - runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3. Some     workarounds are available. Using user namespaces restricts this attack fairly significantly such that the     attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actual user on the host (such as with rootless containers that     don't use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes     in world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

Note that Nessus relies on the presence of the package as reported by the vendor.

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

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3.Some     workarounds are available. Using user namespaces restricts this attack fairly significantly such that the     attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actual user on the host (such as with rootless containers that     don't use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes     in world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested.(CVE-2024-45310)

Tenable has extracted the preceding description block directly from the EulerOS docker-runc security advisory.

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

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

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3.
    Some workarounds are available. Using user namespaces restricts this attack fairly significantly such that     the attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actual user on the host (such as with rootless containers that     don't use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes     in world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested.(CVE-2024-45310)

Tenable has extracted the preceding description block directly from the EulerOS docker-runc security advisory.

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

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

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3. Some     workarounds are available. Using user namespaces restricts this attack fairly significantly such that the     attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actual user on the host (such as with rootless containers that     don't use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes     in world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested.(CVE-2024-45310)

Tenable has extracted the preceding description block directly from the EulerOS docker-runc security advisory.

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

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

    runc is a CLI tool for spawning and running containers according to the OCI specification.runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`.While this could be used to create empty files, existing files would not be     truncated.An attacker must have the ability to start containers using some kind of custom volume     configuration.Containers using user namespaces are still affected, but the scope of places an attacker can     create inodes can be significantly reduced.Sufficiently strict LSM policies (SELinux/Apparmor) can also in     principle block this attack -- we suspect the industry standard SELinux policy may restrict this attack's     scope but the exact scope of protection hasn't been analysed.This is exploitable using runc directly as     well as through Docker and Kubernetes.The issue is fixed in runc v1.1.14 and v1.2.0-rc3. Some workarounds     are available.Using user namespaces restricts this attack fairly significantly such that the attacker can     only create inodes in directories that the remapped root user/group has write access to.Unless the root     user is remapped to an actual user on the host (such as with rootless containers that don't use     `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes in world-     writable directories.A strict enough SELinux or AppArmor policy could in principle also restrict the scope     if a specific label is applied to the runc runtime, though neither the extent to which the standard     existing policies block this attack nor what exact policies are needed to sufficiently restrict this     attack have been thoroughly tested.(CVE-2024-45310)

Tenable has extracted the preceding description block directly from the EulerOS docker-runc security advisory.

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

The version of runc installed on the remote host is prior to 1.1.14-1. It is, therefore, affected by a vulnerability as referenced in the ALAS2NITRO-ENCLAVES-2024-048 advisory.

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3.

    Some workarounds are available. Using user namespaces restricts this attack fairly significantly such that     the attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actualuser on the host (such as with rootless containers that don't     use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes in     world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

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

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

The version of runc installed on the remote host is prior to 1.1.14-1. It is, therefore, affected by a vulnerability as referenced in the ALAS2DOCKER-2024-047 advisory.

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3.

    Some workarounds are available. Using user namespaces restricts this attack fairly significantly such that     the attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actualuser on the host (such as with rootless containers that don't     use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes in     world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

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

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

The version of runc installed on the remote host is prior to 1.1.14-1. It is, therefore, affected by a vulnerability as referenced in the ALAS2ECS-2024-044 advisory.

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3.

    Some workarounds are available. Using user namespaces restricts this attack fairly significantly such that     the attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actualuser on the host (such as with rootless containers that don't     use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes in     world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

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

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

It is, therefore, affected by a vulnerability as referenced in the ALAS2023-2024-725 advisory.

    runc is a CLI tool for spawning and running containers according to the OCI specification. runc 1.1.13 and     earlier, as well as 1.2.0-rc2 and earlier, can be tricked into creating empty files or directories in     arbitrary locations in the host filesystem by sharing a volume between two containers and exploiting a     race with `os.MkdirAll`. While this could be used to create empty files, existing files would not be     truncated. An attacker must have the ability to start containers using some kind of custom volume     configuration. Containers using user namespaces are still affected, but the scope of places an attacker     can create inodes can be significantly reduced. Sufficiently strict LSM policies (SELinux/Apparmor) can     also in principle block this attack -- we suspect the industry standard SELinux policy may restrict this     attack's scope but the exact scope of protection hasn't been analysed. This is exploitable using runc     directly as well as through Docker and Kubernetes. The issue is fixed in runc v1.1.14 and v1.2.0-rc3.

    Some workarounds are available. Using user namespaces restricts this attack fairly significantly such that     the attacker can only create inodes in directories that the remapped root user/group has write access to.
    Unless the root user is remapped to an actualuser on the host (such as with rootless containers that don't     use `/etc/sub[ug]id`), this in practice means that an attacker would only be able to create inodes in     world-writable directories. A strict enough SELinux or AppArmor policy could in principle also restrict     the scope if a specific label is applied to the runc runtime, though neither the extent to which the     standard existing policies block this attack nor what exact policies are needed to sufficiently restrict     this attack have been thoroughly tested. (CVE-2024-45310)

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

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

An update of the runc package has been released.

The remote SUSE Linux SLES12 / SLES_SAP12 host has a package installed that is affected by a vulnerability as referenced in the SUSE-SU-2024:3324-1 advisory.

    - Update to runc v1.1.14
    - CVE-2024-45310: Fixed an issue where runc can be tricked into creating empty files/directories on host.
    (bsc#1230092)

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

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

The remote SUSE Linux SLES15 / SLES_SAP15 / openSUSE 15 host has a package installed that is affected by a vulnerability as referenced in the SUSE-SU-2024:3222-1 advisory.

    - Update to runc v1.1.14
    - CVE-2024-45310: Fixed an issue where runc can be tricked into creating empty files/directories on host.
    (bsc#1230092)

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

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

ID	Name	Product	Family	Severity
234862	SUSE SLES12 Security Update : runc (SUSE-SU-2025:1374-1)	Nessus	SuSE Local Security Checks	medium
233947	Azure Linux 3.0 Security Update: cri-tools / moby-runc / runc (CVE-2024-45310)	Nessus	Azure Linux Local Security Checks	low
233946	CBL Mariner 2.0 Security Update: cri-tools / moby-runc / runc (CVE-2024-45310)	Nessus	MarinerOS Local Security Checks	low
232286	Amazon Linux 2023 : ecs-init (ALAS2023-2025-886)	Nessus	Amazon Linux Local Security Checks	low
232221	Amazon Linux 2 : ecs-init (ALASECS-2025-050)	Nessus	Amazon Linux Local Security Checks	low
229501	Linux Distros Unpatched Vulnerability : CVE-2024-45310	Nessus	Misc.	low
212653	EulerOS 2.0 SP11 : docker-runc (EulerOS-SA-2024-2965)	Nessus	Huawei Local Security Checks	low
212642	EulerOS 2.0 SP12 : docker-runc (EulerOS-SA-2024-2949)	Nessus	Huawei Local Security Checks	low
212613	EulerOS 2.0 SP12 : docker-runc (EulerOS-SA-2024-2934)	Nessus	Huawei Local Security Checks	low
212606	EulerOS 2.0 SP11 : docker-runc (EulerOS-SA-2024-2979)	Nessus	Huawei Local Security Checks	low
210699	EulerOS 2.0 SP9 : docker-runc (EulerOS-SA-2024-2810)	Nessus	Huawei Local Security Checks	low
210688	EulerOS 2.0 SP10 : docker-runc (EulerOS-SA-2024-2883)	Nessus	Huawei Local Security Checks	low
210663	EulerOS 2.0 SP9 : docker-runc (EulerOS-SA-2024-2826)	Nessus	Huawei Local Security Checks	low
210640	EulerOS 2.0 SP10 : docker-runc (EulerOS-SA-2024-2902)	Nessus	Huawei Local Security Checks	low
209067	Amazon Linux 2 : runc (ALASNITRO-ENCLAVES-2024-048)	Nessus	Amazon Linux Local Security Checks	low
209065	Amazon Linux 2 : runc (ALASDOCKER-2024-047)	Nessus	Amazon Linux Local Security Checks	low
209063	Amazon Linux 2 : runc (ALASECS-2024-044)	Nessus	Amazon Linux Local Security Checks	low
208965	Amazon Linux 2023 : runc (ALAS2023-2024-725)	Nessus	Amazon Linux Local Security Checks	low
207734	Photon OS 5.0: Runc PHSA-2024-5.0-0375	Nessus	PhotonOS Local Security Checks	low
207508	SUSE SLES12 Security Update : runc (SUSE-SU-2024:3324-1)	Nessus	SuSE Local Security Checks	low
207270	Photon OS 4.0: Runc PHSA-2024-4.0-0692	Nessus	PhotonOS Local Security Checks	low
207220	SUSE SLES15 / openSUSE 15 Security Update : runc (SUSE-SU-2024:3222-1)	Nessus	SuSE Local Security Checks	low

Detections

Analytics

CVE-2024-45310

medium

Tenable Plugins

medium

low

low

low

low

low

low

low

low

low

low

low

low

low

low

low

low

low

low

low

low

low