Zoom vulnerabilities could enable RCE against meeting participants

Three vulnerabilities were recently discovered in the Zoom video conferencing platform, two of which could enable remote code execution against call participants during screen sharing, A Security reported Tuesday.

The vulnerabilities, dubbed “Zoomsday,” were discovered using AI assistance, with the A Security researchers finding the flaws and developing working exploits within 24 hours — and with less than 20 prompts to publicly available AI models.

A Security Senior Vulnerability Researcher Idan Levcovich told SC Media the team specifically worked with Anthropic’s Claude Opus 4.7 and Opus 4.8 during the research. They also used the IDA Pro MCP plugin to assist with reverse engineering and the Frida MCP for dynamic tracing.

The team dynamically traced the Zoom client while testing different live call features and identified a potential target in the “libannotate.so” library, which handles annotations made during screen sharing or digital whiteboard sharing.

To share annotations between Zoom clients, the program builds each drawing, text box or shape into an in-memory object that is serialized, packaged into a Protocol Data Unit (PDU) and sent to Zoom’s Multimedia Router (MMR) to be routed to the receiver. The object is then deserialized and rendered as annotations on the receiver’s screen.

Related reading:

The researchers asked the AI model to identify any memory safety bugs in the annotation library’s deserializers, leading to the discovery of a buffer overwrite flaw involving the way that text annotation objects are deserialized. Text formatting information is held in an object called CAnnoFormatBlock that comprises a small header and four fixed 128-byte buffers meant to hold UTF-16 strings of up to 64 characters, such as font names.

The character count for each buffer is supplied by the sender client and there are no checks to ensure this count does not exceed 128 bytes. Therefore, if an attacker manipulates this count and supplies more bytes than the buffers can hold, they can write arbitrary content past the end of the fourth buffer.

The researchers noted that the participant sharing their screen is able to send messages over the annotation protocol to any other participant, while other participants are only able to send annotation messages to the sharer. Additionally, under normal circumstances, the sharer can only send acknowledgement (ack) messages rather than annotations back to participants, but the researchers found that the protocol is always open during a screenshare regardless of whether the annotation tools are being used, and an attacker can still perform the buffer overwrite attack against any participants as the sharer.

“Participants send annotations to the sharer, and the sharer can only send ack messages back to the participants; however, the sharer can place an annotation message inside an ack message, and the participant will deserialize it as a regular annotation message,” Levcovich told SC Media. “So the attack itself is simple: the bug is in the specific text annotation, the attacker builds a text annotation with the malformed bytes and sends it over the annotation channel to a specific participant in the call.”

Using Frida and an Android emulator, the researchers could inject the malformed annotation messages to trigger the flaw.

The researchers showed that this buffer overwrite vulnerability, tracked as CVE-2026-53413, could be used to achieve RCE on macOS devices by overwriting stack memory used during the function’s return sequence. The overwritten stack frame allowed the researchers to control restored register values including the link register, which they used to redirect execution to a gadget that loaded the attacker-controlled register values as arguments for execvp.

Neither a stack canary nor a pointer authentication code (PAC) were implemented to prevent the exploit, however, the researchers noted the attacker would need at least one leaked pointer to overcome address space layout randomization (ASLR).

On Android, RCE could be achieved without leaked pointers through heap shaping, as a text annotation message can declare an extension that causes the parser to allocate a 592-byte child object on the heap.  “Spraying” the heap with back-to-back objects allows the attacker to control what comes directly after the overflow, partially overwrite the neighbor’s C++ vtable pointer and trigger a RemoveObj or ModifyObj operation, which causes the destructor to follow the corrupted pointer to an attacker-controlled location.

Two additional flaws were discovered in A Security’s investigation, a buffer over-read tracked as CVE-2026-53414 and a use-after-free tracked as CVE-2026-53415. In the over-read, the deserializer allocates a buffer for glyph annotations based on a count provided by the sender but then reads however many bytes are actually provided regardless of size. This allows memory such as code, vtable pointers and resource strings to leak to the receiver; according to Zoom’s security bulletin, this could also lead to a denial of service for the recipient.

The third flaw can also be used to achieve RCE by manipulating another annotation object known as an autoshape metadata object.

“Zoom’s parser handles a message type internally numbered 75 — an “auto-shape” metadata object (CAnnoObjAutoMetaShape) — by reading attacker-supplied bytes directly into an internal linked-list structure and then unlinking that list, without ever validating the pointers it was handed,” the researchers describe.

This provides a write-what-where primitive that could be exploited for RCE; according to the researchers, Zoom had already added a server-side mitigation for this flaw prior to A Security’s report but that fix did not apply for end-to-end encrypted meetings. Zoom has since released both server-side and client-side patches for all three flaws.

Affected and patched versions are outlined in Zoom’s security bulletins for CVE-2026-53413, CVE-2026-53414 and CVE-2026-53415.