Advisories ยป MGASA-2021-0315

Updated grub2 packages fix security vulnerabilities

Publication date: 08 Jul 2021
Modification date: 08 Jul 2021
Type: security
Affected Mageia releases : 8
CVE: CVE-2020-10713 , CVE-2020-14308 , CVE-2020-14309 , CVE-2020-14310 , CVE-2020-14311 , CVE-2020-14372 , CVE-2020-15705 , CVE-2020-15706 , CVE-2020-15707 , CVE-2021-20225 , CVE-2021-20233 , CVE-2020-25632 , CVE-2020-25647 , CVE-2020-27749 , CVE-2020-27779

Description

All CVEs below are against the SecureBoot functionality in GRUB2.
We do not ship this as part of Mageia. Therefore, we ship an updated grub2
package to 2.06 for Mageia 8 fixing upstream bugfixes.

A flaw was found in grub2, prior to version 2.06. An attacker may use the
GRUB 2 flaw to hijack and tamper the GRUB verification process. This flaw also
allows the bypass of Secure Boot protections. In order to load an untrusted or
modified kernel, an attacker would first need to establish access to the system
such as gaining physical access, obtain the ability to alter a
pxe-boot network, or have remote access to a networked system with root access.
With this access, an attacker could then craft a string to cause a buffer
overflow by injecting a malicious payload that leads to arbitrary code execution
within GRUB. The highest threat from this vulnerability is to data
confidentiality and integrity as well as system availability (CVE-2020-10713).

In grub2 versions before 2.06 the grub memory allocator doesn't check for
possible arithmetic overflows on the requested allocation size. This leads the
function to return invalid memory allocations which can be further used to cause
possible integrity, confidentiality and availability impacts during the boot
process (CVE-2020-14308).

There's an issue with grub2 in all versions before 2.06 when handling squashfs
filesystems containing a symbolic link with name length of UINT32 bytes in size.
The name size leads to an arithmetic overflow leading to a zero-size allocation
further causing a heap-based buffer overflow with attacker controlled data
(CVE-2020-14309).

There is an issue on grub2 before version 2.06 at function
read_section_as_string(). It expects a font name to be at max UINT32_MAX - 1
length in bytes but it doesn't verify it before proceed with buffer allocation
to read the value from the font value. An attacker may leverage that by
crafting a malicious font file which has a name with UINT32_MAX, leading to
read_section_as_string() to an arithmetic overflow, zero-sized allocation and
further heap-based buffer overflow (CVE-2020-14310).

There is an issue with grub2 before version 2.06 while handling symlink on ext
filesystems. A filesystem containing a symbolic link with an inode size of
UINT32_MAX causes an arithmetic overflow leading to a zero-sized memory
allocation with subsequent heap-based buffer overflow (CVE-2020-14311).

A flaw was found in grub2 in versions prior to 2.06, where it incorrectly
enables the usage of the ACPI command when Secure Boot is enabled. This flaw 
allows an attacker with privileged access to craft a Secondary System Description
Table (SSDT) containing code to overwrite the Linux kernel lockdown variable
content directly into memory. The table is further loaded and executed by the
kernel, defeating its Secure Boot lockdown and allowing the attacker to load
unsigned code. The highest threat from this vulnerability is to data
confidentiality and integrity, as well as system availability (CVE-2020-14372).

GRUB2 fails to validate kernel signature when booted directly without shim,
allowing secure boot to be bypassed. This only affects systems where the kernel
signing certificate has been imported directly into the secure boot database
and the GRUB image is booted directly without the use of shim. This issue
affects GRUB2 version 2.04 and prior versions (CVE-2020-15705).

GRUB2 contains a race condition in grub_script_function_create() leading to a
use-after-free vulnerability which can be triggered by redefining a function
whilst the same function is already executing, leading to arbitrary code
execution and secure boot restriction bypass. This issue affects GRUB2 version
2.04 and prior versions (CVE-2020-15706).

Integer overflows were discovered in the functions grub_cmd_initrd and
grub_initrd_init in the efilinux component of GRUB2, as shipped in Debian,
Red Hat, and Ubuntu (the functionality is not included in GRUB2 upstream), 
leading to a heap-based buffer overflow. These could be triggered by an extremely
large number of arguments to the initrd command on 32-bit architectures, or a
crafted filesystem with very large files on any architecture. An attacker could
use this to execute arbitrary code and bypass UEFI Secure Boot restrictions.
This issue affects GRUB2 version 2.04 and prior versions (CVE-2020-15707).

A flaw was found in grub2 in versions prior to 2.06. The option parser allows an
attacker to write past the end of a heap-allocated buffer by calling certain
commands with a large number of specific short forms of options. The highest
threat from this vulnerability is to data confidentiality and integrity as well
as system availability (CVE-2021-20225).

A flaw was found in grub2 in versions prior to 2.06. Setparam_prefix() in the
menu rendering code performs a length calculation on the assumption that
expressing a quoted single quote will require 3 characters, while it actuall
requires 4 characters which allows an attacker to corrupt memory by one byte for
each quote in the input. The highest threat from this vulnerability is to data
confidentiality and integrity as well as system availability (CVE-2021-20233).

A flaw was found in grub2 in versions prior to 2.06. The rmmod implementation
allows the unloading of a module used as a dependency without checking if any
other dependent module is still loaded leading to a use-after-free scenario.
This could allow arbitrary code to be executed or a bypass of SecureBoot
protections. The highest threat from this vulnerability is to data
confidentiality and integrity as well as system availability (CVE-2020-25632).

A flaw was found in grub2 in versions prior to 2.06. During USB device
initialization, descriptors are read with very little bounds checking and assumes
the USB device is providing sane values. If properly exploited, an attacker
could trigger memory corruption leading to arbitrary code execution allowing a
bypass of the Secure Boot mechanism. The highest threat from this vulnerability
is to data confidentiality and integrity as well as system availability
(CVE-2020-25647).

A flaw was found in grub2 in versions prior to 2.06. Variable names present are
expanded in the supplied command line into their corresponding variable contents
using a 1kB stack buffer for temporary storage, without sufficient bounds
checking. If the function is called with a command line that references a
variable with a sufficiently large payload, it is possible to overflow the stack
buffer, corrupt the stack frame and control execution which could also circumvent
Secure Boot protections. The highest threat from this vulnerability is to data
confidentiality and integrity as well as system availability (CVE-2020-27749).

A flaw was found in grub2 in versions prior to 2.06. The cutmem command does not
honor secure boot locking allowing an privileged attacker to remove address
ranges from memory creating an opportunity to circumvent SecureBoot protections
after proper triage about grub's memory layout. The highest threat from this
vulnerability is to data confidentiality and integrity as well as system
availability (CVE-2020-27779).

References

SRPMS

8/core