CVE-2022-20564 in Android
Summary
by MITRE • 12/16/2022
In _ufdt_output_strtab_to_fdt of ufdt_convert.c, there is a possible out of bounds write due to an incorrect bounds check. This could lead to local escalation of privilege with System execution privileges needed. User interaction is not needed for exploitation.Product: AndroidVersions: Android kernelAndroid ID: A-243798789References: N/A
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 04/22/2026
The vulnerability identified as CVE-2022-20564 represents a critical out-of-bounds write flaw within the Android kernel's device tree conversion functionality. This issue resides in the ufdt_output_strtab_to_fdt function located in the ufdt_convert.c source file, where an incorrect bounds check allows for memory corruption during device tree processing operations. The vulnerability specifically affects Android kernel implementations and has been assigned Android ID A-243798789, indicating its significance within the Android security framework.
The technical flaw stems from improper validation of string table boundaries when converting device tree structures, creating a scenario where malicious input can cause the system to write data beyond allocated memory regions. This memory corruption occurs during the translation process from flattened device tree format to standard device tree format, a critical operation performed during system boot and device initialization phases. The incorrect bounds check fails to properly validate the length of string data being written to the destination buffer, allowing for buffer overflow conditions that can be exploited to overwrite adjacent memory locations.
The operational impact of this vulnerability is severe, as it enables local privilege escalation from system execution privileges to full root access. An attacker with local system execution capabilities can leverage this flaw to gain elevated privileges without requiring user interaction, making it particularly dangerous in environments where local access is possible. The vulnerability's exploitation does not require user interaction, which significantly broadens the attack surface and makes it more accessible to threat actors. This privilege escalation capability allows attackers to execute arbitrary code with the highest system privileges, potentially leading to complete system compromise and persistent access.
From a cybersecurity perspective, this vulnerability maps directly to CWE-121, which describes heap-based buffer overflow conditions, and aligns with ATT&CK technique T1068, which covers 'Exploitation for Privilege Escalation'. The flaw represents a classic buffer overflow vulnerability that can be exploited to execute malicious code with elevated privileges. The Android kernel's device tree processing functionality serves as a critical system component, making this vulnerability particularly dangerous as it can affect system initialization processes and device driver operations. The vulnerability's classification as a local privilege escalation issue means that any user with access to system execution capabilities can potentially exploit this flaw to gain root privileges.
Mitigation strategies should focus on implementing proper bounds checking in the device tree conversion functions, applying kernel updates that contain the patched version of ufdt_convert.c, and implementing memory protection mechanisms such as stack canaries and address space layout randomization. Additionally, system administrators should monitor for unauthorized local access and implement strict access controls to limit potential exploitation vectors. The vulnerability highlights the importance of thorough input validation in kernel-level code and demonstrates the critical need for robust memory safety mechanisms in system firmware and kernel components.