Recently, a major vulnerability (CVE-2022-48564) was discovered in Python's, which is responsible for processing Apple Property List (Plist) files. Plist files are primarily used for storing user preferences, configuration files, and application states in macOS and iOS systems. This vulnerability affects Python through version 3.9.1.

In this post, we will delve into the details of this security flaw, analyze the code snippet responsible for the vulnerability, and discuss potential risks and exploitation techniques. But first, let's look at the basics of and the specific function at the heart of this vulnerability. and read_ints Function

The module in Python is part of the standard library and provides an interface for working with property lists (Plist). The module supports both XML and binary formats for these files, helping developers read, modify, and write Plist files with ease.

One of the core functions in is read_ints, which is responsible for reading integers from binary Plist files. The issue with this function lies in how it processes certain malformed Apple Property List files in binary format, making it susceptible to a Denial-of-Service (DoS) attack.

Vulnerability Analysis

The vulnerability occurs when the read_ints function within attempts to process binary Plist files containing malformed data structures. This can lead to high CPU and RAM usage, causing a DoS attack.

Here's the problematic code snippet from

def read_ints(self, byte_size, count):
    data = * count)
    if byte_size == 1:
        return struct.unpack("B" * count, data)
    elif byte_size == 2:
        return struct.unpack(">" + "H" * count, data)
    elif byte_size == 4:
        return struct.unpack(">" + "L" * count, data)
    elif byte_size == 8:
        return struct.unpack(">" + "Q" * count, data)
        raise ValueError("invalid byte_size: %r" % byte_size)

The issue arises when the function tries to unpack the user-supplied data using the struct.unpack function, which can lead to both CPU and RAM exhaustion if the Plist file being processed is sufficiently large or the data is malformed in a specific manner.

Exploiting the Vulnerability

An attacker could potentially exploit this vulnerability by crafting a Plist file containing malformed structures that trigger high memory and CPU consumption when processed. These malicious files could then be used to target systems or applications that rely on for processing binary Plist files, causing a severe degradation in performance or a complete Denial-of-Service (DoS) condition.

Mitigation and Remediation

Unfortunately, there is no patch available at the time of writing this post. However, developers and system administrators working with should exercise caution when processing binary Plist files and consider implementing strict input validation and resource limits to prevent potential exploitation of this vulnerability.

It is strongly recommended to keep Python packages up to date. Keep an eye out for announcements and updates regarding this vulnerability from the Python community and security researchers.


CVE-2022-48564 exposes a crucial vulnerability in Python's, which can lead to a potential DoS attack via CPU and RAM exhaustion when processing malformed Apple Property List files in binary format. Developers using are advised to be cautious when handling unknown binary Plist files and watch for updates from the Python community addressing this issue.

Original References

- Python Documentation - plistlib -
- National Vulnerability Database - CVE-2022-48564 -


Published on: 08/22/2023 19:16:00 UTC
Last modified on: 10/11/2023 23:15:00 UTC