Introduction

My previous post on Macfinger ClickFix was two days ago, and this campaign remains active. The more I look into the malware delivered by this campaign, the more I believe it is not a variant of Atomic macOS (AMOS) Stealer as originally reported. There are too many differences between what I've documented with recent AMOS Stealer activity and what I'm now seeing with this malware. The data collection and method of exfiltration is different between these two malware families. The persistence mechanism is different. Finally, AMOS Stealer uses an installer with a combined arm64/x86_64 architecture, but this malware uses either an arm64 or an x86_64 Mach-O binary depending on the architecture of the victim's host. There are too many differences with this malware.

The malware delivered by Macfinger ClickFix is indeed an information stealer. I just don't know what to call it.

In an attempt to find out, this diary examines an infection from the Macfinger ClickFix campaign on Thursday, 2026-09-24. This infection was on a physical host running macOS 27.0 (Golden Gate).

Shown above: Example of a fake CAPTCHA/verification page generated in the Macfinger ClickFix campaign.

The Macfinder Domain and ClickFix Text

On Thursday 2026-09-24, the Macfinder domain for the fake verification page was hollow-badger-moasfraum[.]life. The clipboard-injected text was similar to what I reported in my previous diary, and I pasted it into a Terminal window.

Shown above: Clipboard-injected text from the Macfinger ClickFix campaign pasted in a Terminal window.

I saw the same message in my Terminal window after running the ClickFix text as the message noted in the Ransom-ISAC blog.

Shown above: Terminal window after running the ClickFix text.

Loader Activity

The ClickFix text retrieved a loader from hxxp[:]//45.131.215[.]56/8031e818c7a46?force=1. This loader is a shell script, and it saves a binary under the user's /Library/Caches/com.apple.securityd/ directory as com.apple.periodic.

If com.apple.periodic already exists and is running, the script will kill that running process.

Shown above: The initial downloaded shell script showing a location of a binary.

The script checks the system's architecture using uname -m and will download the appropriate payload depending on the architecture. Apple silicon is arm64, while systems using an Intel processor are x86_64. The corresponding URLs are:

• arm64 Mach-O binary: hxxp[:]//45.131.215[.]56/a7a11f95?force=1
• x86_64 Mach-O binary: hxxp[:]//45.131.215[.]56/4e04813226b1b93?force=1

Shown above: A later section of the downloaded shell script showing URLs for the follow-up malware.

A string of base64 text shown in the above image translates to a URL for the C2 server: hxxp[:]//95.163.153[.]80:8133/api/t

Post-Infection C2 Traffic

The post-infection C2 traffic on Thursday 2026-09-24 went a different IP address than I reported in my previous diary. But the URL patterns remained the same.

Shown above: Traffic from the infection filtered in Wireshark.

After retrieving the Mach-O binary, the infected macOS host reported to the C2 server that the download from the arm64 URL was good.

Shown above: The infected host reporting to the C2 server.

The infected host also reported to the server when the malware was executed (exec_start) and if it ran successfully (exec_ok). Then through more POST requests to the same /api/t URL, the infected host started reporting more information, and I started seeing the User-Agent string as Go-http-client/1.1.

Shown above: More traffic to the C2 server.

For C2-traffic, the biggest difference I've seen from AMOS Stealer is that this stealer uses websocket traffic.

Shown above: Request to switch protocol to websocket traffic.

In addition to websocket traffic, the infected host continued to send other HTTP POST requests. The next three images show an example of data exfiltration consisting of two HTTP requests in a single TCP stream.

These POST requests for data exfiltration used /api/credentials in the URL.

Shown above: Start of one of the HTTP POST requests for data exfiltration.

Shown above: End of one of the HTTP POST requests for data exfiltration.

Shown above: Follow-up HTTP POST request in the same TCP stream reporting "upload_session_ok."

Before exfiltrating various types of data, my infected macOS host asked to allow access to different folders and applications.

Permissions Requested by the Malware

The following images show the pop-ups I saw on my infected macOS host for access to various applications and folders.

Shown above: The first two access request pop-ups on my infected macOS host.

Shown above: The next four access request pop-ups on my infected macOS host.

The last pop-up requests were for my administrator password and my macOS Keychain password. The pop-up for the macOS Keychain password would not accept the administrator password, and I had not set up a separate password for it on the macOS host.

Shown above: The final pop-ups on my infected macOS host for passwords.

The pop-up messages were:

• "bash" wants access to control the "Notes.app".
• "Terminal.app" would like to access files in your Documents folder.
• "Terminal.app" would like to access files in your Desktop folder.
• "Terminal.app" would like to access files in your Downloads folder.
• Allow "Terminal.app" to access your music, video activity, and media library in Apple Music?
• Allow "Terminal.app" to access your photo library?
• System Error pop-up requesting administrator password
• macOS Keychain requires a separate password to protect your saved credentials.

Persistent Malware

A copy of the malware binary was made persistent through the following .plist file:

• /Users/[username]/Library/LaunchAgents/com.apple.softwareupdated.plist

The above .plist file runs a copy of the Mach-O binary at:

• /Users/[username]/Library/Caches/com.apple.softwareupdate/SoftwareUpdate

Notably, copies of the Mach-O binary were different from each other. They had slightly different file sizes and different SHA-256 hashes.

• 33,492,336 bytes - Initial Mach-O arm64 binary from hxxp[:]//45.131.215[.]56/a7a11f95?force=1
• 33,297,728 bytes - First saved binary at /Users/[username]/Library/Caches/com.apple.securityd/com.apple.periodic
• 33,297,760 bytes - Persistent binary at /Users/[username]/Library/Caches/com.apple.softwareupdate/SoftwareUpdate

They all appear to be copies of the same binary but with some relatively slight differences from each other.

Indicators of Compromise

SHA-256 hash: c6da028e0a8a25a35efa28ba508a556d1b53d1e61113c0aaebf31a49a5668912
Description: Shell script loader from 45.131.215[.]56

SHA-256 hash: 457ed02b0a63ccf872e8459c91e2d1d6844a75414358849333f518cc538055b7
Description: x86_64 Mach-O binary from 45.131.215[.]56

SHA-256 hash: 5a2242b862ef52fe7a08af596198412a7676c948bcd64a25ce5d2e6d4b35c6fb
Description: arm64 Mach-O binary from 45.131.215[.]56

SHA-256 hash: 3e26e006210ed398f98c090e9f1c982e76b3b73f1ce3e04ee1bf8d45c56e1a89
Description: arm64 Mach-O binary first saved to disk com.apple.periodic

SHA-256 hash: 4a5952849232691849ed900609d7ff271ce296fe3cee4a81b58c28f2839fb5b6
Description: Persistent arm64 Mach-O binary SoftwareUpdate.bin

Location of files retrieved from the infected macOS host:

• /Users/[username]/Library/LaunchAgents/com.apple.softwareupdated.plist
• /Users/[username]/Library/Caches/com.apple.securityd/com.apple.periodic
• /Users/[username]/Library/Caches/com.apple.softwareupdate/SoftwareUpdate

Macfinder ClickFix domain:

• hollow-badger-moasfraum[.]life

Malware hosting URLs:

• hxxp[:]//45.131.215[.]56/4e04813226b1b93?force=1
• hxxp[:]//45.131.215[.]56/8031e818c7a46?force=1
• hxxp[:]//45.131.215[.]56/a7a11f95?force=1

Post-infection C2 URLs:

• hxxp[:]//95.163.153[.]80:8133/api/credentials
• hxxp[:]//95.163.153[.]80:8133/api/shell/agent
• hxxp[:]//95.163.153[.]80:8133/api/t

Final Words

As noted earlier, I don't think the malware is a variant of AMOS Stealer. However, I still don't know what to call it, and I could still be wrong. I suspect people more experienced with macOS malware can confirm what, exactly, this malware from the Macfinder ClickFix campaign is.

A packet capture (pcap) of the infection traffic and copies of the associated malware are available here.

Bradley Duncan
brad [at] malware-traffic-analysis.net

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

Yesterday, we received a phishing email with an interesting link. At first sight, it looks like garbage, but every piece of it has been carefully crafted to confuse basic security controls. Here is the defanged link:

hxxps://YKZjqa7A@gynd--[.]koncar-hr[.]com/handlers@isc.sans.edu

Let's break it down...

The first trick is the old "userinfo" field. According to RFC 3986[1], everything between the scheme and an "@" inside the authority is treated as credentials ("user:password@host"). Browsers silently ignore it, but it has two advantages for the attacker. The random string ("YKZjqa7A") makes every URL unique, which defeats exact-match blocklists and URL reputation lookups. It probably also acts as a tracking token per victim or campaign. As a side effect, the whole thing now looks like an email address to any tool that doesn't parse URLs strictly.

The second trick is the hostname itself: "gynd--.koncar-hr.com". Per the classic hostname rules (RFC 952/1123[2]), a label can't start or end with a hyphen. DNS doesn't care, and browsers happily resolve and visit it. However, strict validators, regex-based URL extractors, and some link-rewriting or sandboxing solutions may consider it invalid and simply skip it. A URL that is never extracted is never scanned. The random subdomain also suggests wildcard DNS, so each victim gets a brand-new hostname that no blocklist knows. The parent domain is a lookalike of the legitimate "koncar.hr" (a Croatian industrial group), with the ccTLD turned into a hyphenated ".com".

The last trick is the victim's email address, appended in the path. This is common with phishing kits: the page reads the path, pre-fills the login form with the victim's address, and sometimes adapts the branding to the email domain. There is another benefit, though. A poorly written parser that splits the string on the last "@" will conclude that the host is "isc.sans.edu", the recipient's own trusted domain! Per the WHATWG[3] URL standard, the authority ends at the first "/", so the browser correctly connects to the attacker's server.

The result is a single string that tells three different stories. A naive filter sees two email addresses or a link to your own domain. A strict validator sees an invalid hostname and drops it. The browser sees a perfectly valid URL and takes the victim straight to the phishing page. Attackers aren't exploiting a vulnerability here but the differences between parsers.

Tip: If you want to hunt for this kind of link, look for URLs with more than one "@", hostname labels starting or ending with a hyphen, and paths containing the recipient's own email address.

[1] https://www.rfc-editor.org/info/rfc3986/
[2] https://www.rfc-editor.org/info/rfc952/
[3] https://url.spec.whatwg.org

Xavier Mertens (@xme)
Senior ISC Handler | SANS Principal Instructor | Freelance Consultant
Xameco | PGP Key

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

Introduction

I've found several legitimate websites with injected script for a campaign using the ClickFix social engineering technique. This particular ClickFix campaign was documented earlier this month on the Ransom-ISAC Blog, but it doesn't appear to have a nickname yet. Since this campaign is targeting macOS environments through a fingerprinting process, I'm calling it the "Macfinger ClickFix" campaign. No, this is not related to the MacFinger utility from decades ago. Instead, think of the movie Goldfinger, but with macOS malware and the internet instead of James Bond and Miss Galore.

Shown above: An image I created to represent the Macfinger ClickFix campaign.

Today's diary presents indicators from the Macfinger ClickFix campaign that I saw on Tuesday, 2026-09-22.

Images From the Infection

Shown above: First part of the Macfinger injected script in a page from a legitimate website.

Shown above: Second part of the Macfinger injected script in a page from a legitimate website.

Shown above: Fake bot protection page caused by the injected Macfinger script.

Shown above: ClickFix instructions from fake verification pop-up caused by the injected Macfinger script.

While displaying the fake bot protection page with the verification instructions, the Macfinger domain receives frequent POST requests from the victim host. These report information on the user and track the user actions. Here's an example of a POST request through HTTPS traffic after the user has clicked on the page. In this case, the user abandoned the page without following the instructions.

Shown above: POST request over HTTPS to the Macfinger domain reporting the user information.

I had tested one of the Macfinger-infected sites on Monday, 2026-09-21 which had the same post-infection traffic that I saw the next day on Tuesday, 2026-09-22. The image below shows an example of the infection traffic, with the malware files retrieved from 45.150.33[.]128 and the post-infection C2 traffic on 95.163.153[.]80 over TCP port 8133.

Shown above: Traffic from an infection filtered in Wireshark.

Indicators of Compromise

The following are indicators from Tuesday, 2026-09-22.

Traffic to the Macfinger domain:

• hxxps[:]//velvet-otter-glagceis[.]life/t.js?site=4f0529f47320472732961318d7d0dfd1
• hxxps[:]//velvet-otter-glagceis[.]life/t.4b1009ff6c3f.js
• hxxps[:]//velvet-otter-glagceis[.]life/ext-b.4f9db6afd06a.js
• hxxps[:]//velvet-otter-glagceis[.]life/collect
• hxxps[:]//velvet-otter-glagceis[.]life/collect
• hxxps[:]//velvet-otter-glagceis[.]life/collect
• hxxps[:]//velvet-otter-glagceis[.]life/collect
• hxxps[:]//velvet-otter-glagceis[.]life/collect
• hxxps[:]//velvet-otter-glagceis[.]life/collect
• hxxps[:]//velvet-otter-glagceis[.]life/collect
• hxxps[:]//velvet-otter-glagceis[.]life/collect

ClickFix text from the Macfinger domain, saved to a text file:

SHA-256 hash: 6606a5f18184b224a56c9cb658fa26f7fce45099da548a30a8db2c5f2c70377c

• File size: 581 bytes

Initial download:

SHA-256 hash: 9d87b41c2b29ccbeac851b98f1a7dce4ab4781fec0cbc55fa6f93a6299a3d564

• File size: 4,674 bytes
• File type: Bourne-Again shell script text executable, ASCII text, with very long lines
• File location: hxxp[:]//45.150.33[.]128/92961f75b259df2?force=1

Follow-up malware from the above shell script:

SHA-256 hash: b68cdb1b46502fbce67ce3f8110682936d06afd2116af096e30abd4c8376b6dc

• File size: 33,285,040 bytes
• File type: Mach-O 64-bit executable arm64
• File location: hxxp[:]//45.150.33[.]128/d4c8083a7d97?force=1

SHA-256 hash: 1a3765e8cb0055ec31693b8f82ce9744106dee08368259661600b072c6805af4

• File size: 34,118,904 bytes
• File type: Mach-O 64-bit executable x86_64
• File location: hxxp[:]//45.150.33[.]128/2286de55f9afd?force=1

Post-infection Traffic:

• 2026-09-21 23:12:58 UTC - hxxp[:]//45.150.33[.]128 - GET /92961f75b259df2?force=1
• 2026-09-21 23:12:59 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:12:59 UTC - hxxp[:]//45.150.33[.]128 - GET /d4c8083a7d97?force=1
• 2026-09-21 23:13:04 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:05 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:05 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:08 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:08 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:11 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:14 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:15 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:20 UTC - ipinfo[.]io - HTTPS traffic
• 2026-09-21 23:13:21 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:21 UTC - hxxp[:]//95.163.153[.]80:8133 - GET /api/shell/agent
• 2026-09-21 23:13:21 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:21 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:22 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:22 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:23 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:23 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:23 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:24 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:26 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:30 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:30 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:30 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:30 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/credentials
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• 2026-09-21 23:13:31 UTC - hxxp[:]//95.163.153[.]80:8133 - POST /api/t
• And so on...

Final Words

The Ransom-ISAC article on this activity calls the final malware a variant of Atomic macOS (AMOS) Stealer. The indictors I found here don't fully align with the AMOS Stealer activity I've previously reported from a different (non-ClickFix) campaign, so this is a different variant than the AMOS Stealer I've looked into.

For mitigation and protection against Macfinger and other ClickFix campaigns, see guidance from the Microsoft Security Blog.

Macfinger ClickFix seems like a fairly widespread campaign, but I haven't found much about it because 1) it seems relatively new and 2) it's only targeting macOS hosts.

Bradley Duncan
brad [at] malware-traffic-analysis.net

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

On Friday, Xavier talked about the newly introduced HTTP Query method. This new method was introduced to allow "GET" requests that include a body. The main reason for this was that GET requests typically do not contain a body. But what if they do?

The HTTP RFCs had "issues" defining this properly. RFC2616, which originally defined HTTP 1.1, stated in section 4.3:

A message-body MUST NOT be included in a request if the specification of the request method (section 5.1.1) does not allow sending an entity-body in requests. 

And the GET specification never discussed message bodies.

This was somewhat reworded in the newer version, RFC 7231, section 4.3.2:

​​​​​​A payload within a GET request message has no defined semantics; sending a payload body on a GET request might cause some existing implementations to reject the request.

I did a quick check of a couple of common web servers I had handy, to see what would happen:

Apache

For this test, I ran Apache 2.4.68 on a Mac. It happily accepted a body with a GET request:

% nc -c localhost 8080
GET /cgi-bin/test-cgi HTTP/1.1
Host: localhost
Content-Length: 6

TEST
HTTP/1.1 200 OK
Date: Tue, 22 Sep 2026 14:39:17 GMT
Server: Apache/2.4.68 (Unix)
Transfer-Encoding: chunked
Content-Type: text/plain; charset=iso-8859-1

18a
CGI/1.0 test script report:
[some details omited]
CONTENT_LENGTH = 6
BODY = TEST

The data was collected using a slightly modified version of the standard "test-cgi" script. The body was received just fine, and a 200 status was returned.

NGINX

% nc -c 10.128.1.11 80
GET /cgi-bin/test-cgi HTTP/1.1
Host: localhost
Content-Length: 6

TESTHTTP/1.1 301 Moved Permanently
Server: nginx

The request still did not trigger an error. But the body was ignored. The server started sending the response as soon as it received the headers. The body was ignored.

Python

A simple Python web server (python -m http.server 8000) appears to behave just like NGINX. The body is ignored, but a response is sent back, and the status code is 200. 

Node

Node also ignores the Content-Length header and processes the request without error.

lighthttpd

lighttpd/1.4.74 will return a 400 error and refuse to process the request.

Java/Tomcat

Tomcat ignores the Content-Length header but returns a 200 response.

Do you have any web servers to test to see how they respond to a GET request with a body?

--
Johannes B. Ullrich, Ph.D. , Dean of Research, SANS.edu
Twitter|

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

Microsoft Security Research published an interesting blog post "TerminalFix campaign deploys a reverse tunnel through multistage intrusion" about a malware campaign. The aspect that I want to take a closer look at, is the fact that the threat actors used PNG files with steganography. I reached out to the researchers and they kindly shared the IOCs for the PNG files with me.

The first image is a small PNG file (f5f1eb6d43dd61d5b069c250e5c666384f7417d0c95014773bf9edf8ff13bebe).

Analysis with pngdump.py reveals that this is a proper PNG file:

There is no data appended to the end of the image. The image starts with the expected header, and has the 3 type of chunks one expects to find in a minimal PNG file: IHDR, IDAT and IEND. There is no metadata that can contain a payload. The IDAT chunk contains the pixels of the image: encoded and ZLIB compressed. The fact that pngdump was able to decompress the IDAT data, is another indication that this is a PNG image with valid IDAT data. It consists of 111 lines and 112 columns. All of the filters of the scanlines are known filters: yet another indication that this is valid data. Thus everything indicates that this is a valid image. If it contains a payload, then it hides in the pixels, and we can confirm that steganography is used.

Let's take a look at the decompressed IDAT data (the scanlines that make up the image):

We can see strings like MZ, .text, .data, ... All strings often found inside a Windows executable (PE file). It's very likely that there is a PE file hiding in the pixel data, but what we see here is the encoded pixel data.

The picture consists of 111 scanlines. The first byte is the type of the filter. Value 01, seen at the start of the decompressed data, indicates that the first line is encoded with the SUB (subtract) filter. 8 bits are used to encode pixel data, and the colortype is 6, e.g., RGBA. This means that there are 4 bytes for each pixel: 1 for Red, 1 for Green, 1 for Blue and 1 for Alpha (transparency). 112 columns times 4 bytes gives 448 bytes per scanline.

A filter of type SUB means that the RGBA values of a pixel are substracted from the RGBA values of the previous pixel (except for the first pixel). Thus this is a transformation that needs to be applied to obtain the raw pixel data. And SUB is not the only filter, there are 5 different filter types.

But the easiest way to obtain the raw bitmat data is to use option -R (--raw):

We can now see the familiar DOS stub "This program ...".

The first 8 bytes of this raw bitmap is actually the length of the embedded PE file.

It's stored little-endian:

We can use this length (49720) to carve out the PE file and calculate its hashes:

The embedded PE file is a genuine Microsoft executable. That executable, LockScreenContentServer.exe, is used for sideloading.

So the payload is indeed stored inside the PNG file using steganography. Usually, when using steganography, only some of the available bits will be used to store the payload, and the others will be left untouched. If this is done with least significant bits, the medium can still be rendered, and is hard to visually distinguish from the original medium.

But in this campaign, the threat actors decided to use all of the available bits. The original medium is lost, and the PNG looks like this when rendered:

The 2 other PNG files contain the malicious payload (a DLL), stored in 2 parts, also using all the bits.

This image contains the first part:

And this image contains the second part:

Concatenating both parts gives the payload, a malicious DLL.

 

Didier Stevens
Senior handler
blog.DidierStevens.com

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

In June 2026 the IETF published RFC 10008[1], defining a new HTTP method: "QUERY". The HTTP protocol faced already by changes (HTTP/2, HTTP/3) but it’s the first new standard HTTP verb since "PATCH" in 2010!

This new method sits between “GET” and “POST” and can be resumed like this: “QUERY is a GET with a body”. It's safe and idempotent: the request is processed without state change and can be automatically repeated or restarted without concern for partial state changes. The query itself lives in the request body instead of the URL, and it's explicitly cacheable. Servers advertise the body formats they'll accept via a new “Accept-Query” response header.

If you defend web infrastructure, the interesting part isn't the RFC. The risk is that every control you own that pattern-matches on HTTP methods was written before "QUERY" existed. WAF rules, API-gateway allowlists, CSRF middleware, cache keying, load-balancer method handling is written in terms of a known verb set: GET, POST, PUT, DELETE, PATCH.  Drop a sixth verb that behaves like a hybrid of the first two into that world and each control now has to make a deliberate decision about it. Most of them currently make an accidental one.

And the behaviour in the wild is genuinely inconsistent. Researchers found that nginx's limit_except pattern and Django's View class reject QUERY outright, while curl, FastAPI's explicit routes, Caddy and Traefik pass it through untouched. On caching, one researcher built a QUERY-only API and found nginx forwards it happily and caches it never[2].

Think about this HTTP request:

curl -X QUERY https://target.com/api/search \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "q=' OR 1=1--" -v

If your WAF signatures (SQLi, XSS, command injection) are bound to "POST" bodies but never taught that "QUERY" also carries a body, you get a clean inspection bypass. The test is trivial: send the same malicious payload over "POST" and over "QUERY" and diff the outcome. If the "QUERY" version sails through where the "POST" version gets blocked, that's a live gap, not a theoretical one.

Because "QUERY" is cacheable and safe by spec, caches that don't key on the full request body can be poisoned into serving one user's malicious payload to the next, and CSRF middleware hardcoded to the classic state-changing verbs will wave through any "QUERY" endpoint that carries an unintended side effect.

The new method is not popular yet, here is an overview of what I found:

Layer	Component	Status
Clients	curl	Works today via "-x query"
	Node.js / fetch (server-side), Python (httpx/requests), Go net/http, Rust reqwest	Already let you send arbitrary method strings, so QUERY works between your own services right now
	Browser fetch() / XHR	Can send it, but QUERY is not CORS-safelisted → always triggers an OPTIONS preflight; browser HTTP cache should not be assumed to cache QUERY responses yet
	.NET 10	First-class support out of the box
	HTTP.jl (Julia)	Merged June 2026 — client + server, retries, redirect handling, Accept-Query
Servers / proxies	nginx	Proxies it, never caches it. Four identical QUERY requests hit the backend four times; four POSTs hit it once. Also, the limit-except pattern silently rejects QUERY.
	Caddy, Traefik	Pass it through untouched
	Apache	Needs config adjustment to recognize the method and handle OPTIONS/CORS
Frameworks	Fast API	Explicit routes pass it through
	Django	The View class rejects it outright
	Spring (Java)	Maintainers deliberately scoping it down to "teach the framework QUERY exists" and waiting on adoption feedback before expanding
CDN	Cloudflare, Akamai	Co-authored the RFC, so edge/CDN support is expected to lead framework support, but reliable at-scale QUERY caching isn't there yet

What can you actually do?

Update your rules/regexes to support the new verb:

http.method in ("GET","POST", "QUERY")

I searched across my HTTP-related logs and found no occurrence of QUERY request but it’s for sure a question of time.

And from a malware point of view? Is there a risk? Most of what a modern SOC actually relies on to catch C2 is behavioral, and behavioral detection doesn't care about the verb:

• Beaconing analysis (RITA/AC-Hunter-style connection-count and interval work), jitter/timing, volume, and flow shape are all method-agnostic. A "QUERY" beacon beacons exactly like a "POST" beacon.
• JA3/JA4 and TLS fingerprinting sit below the HTTP method entirely.
• For HTTPS C2 — which is nearly everything now — the method is inside  the TLS tunnel. A network sensor without interception never sees "GET" vs "POST" vs "QUERY" in the first place, so "QUERY" changes nothing unless you're decrypting.

[1] https://www.rfc-editor.org/info/rfc10008/
[2] https://dev.to/alexgeorgiev17/nginxs-limitexcept-block-silently-rejects-the-new-http-query-method-1gcg

Xavier Mertens (@xme)
Senior ISC Handler | SANS Principal Instructor | Freelance Consultant
Xameco | PGP Key

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

At the end of August, a malspam message was caught in the quarantine of a mail gateway operated by one of my customers. The message was not especially remarkable – it asked the recipient to review some attached requirements and provide a price quotation for a fiber optic system and appeared to impersonate an employee of a legitimate company.

The receiving gateway quarantined the message because it detected malicious content in the attachment, though even if it didn’t, the e-mail would not have gotten much further due to failed SPF and DMARC checks.

Nevertheless, it was the attachment that turned out to be worth a closer look.

The archive attached to the message had an '.r01' extension and contained a roughly 613 KB file named 'PO.4843293191 For Supply Chain - Imports HM..js'. At the time of writing, the file had a 28/55 detection rate on VirusTotal[1], with several engines providing information about the malware family this script belongs to – that being LausivLoader.

Looking at the script, one could hardly miss the large number (450 in total) of comment lines containing seemingly random English words.

After these were removed, much of the remaining 205 KB bulk of the file consisted of slightly obfuscated code for putting together several long strings rather than a particularly complicated JavaScript.

In cases when one sees obviously obfuscated or encoded code, it is often beneficial to start with the analysis at the end of the file and work upwards. If we were to look at then end of this code, we would find, several string fragments constructed using 'String.fromCharCode' being combined with one of the aforementioned large strings to form a command line call, with the last line trying to execute it:

As I have mentioned before, it is often useful to let malicious code decode or deobfuscate itself, rather than manually reproducing every transformation[2]. In this case, redirecting the final result to a text file would make the command line much easier to inspect.

For example, one could simply replace the Run call with the following code, and get the full command line call.

var s = new ActiveXObject("ADODB.Stream");
s.Type = 2;
s.Charset = "utf-8";
s.Open();
s.WriteText(v6177);
s.SaveToFile("C:\\output.txt", 2);
s.Close();

There is an important qualification, however. Replacing the last line would – of course – not neutralize this entire script, and would not provide us with everything needed for further analysis.

In this case, it is because earlier code copies the JavaScript to another location, attempts to register a scheduled task, and writes two other files. Before we look at all of this, let’s get back to the deobfuscated command line call – as you can see below, it was intended to call 'conhost.exe', which was supposed to launch PowerShell with an encoded command.

C:\Windows\System32\conhost.exe --headless "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe" -NoP -NonI -W Hidden -EncodedCommand <Base64 code>

Decoding the Base64-encoded argument revealed a relatively short PowerShell script, first few lines of which were particularly interesting:

We can clearly see that the PowerShell code tries to load files from paths saved in two environment variables – Kv7408 and Kv562 – which is somewhat unusual way for inter-process data handoff. It is also one of the reasons why looking only at the decoded command would leave us with an incomplete picture.

If we returned to the JavaScript, we would find the reason for this behavior – i.e., the reason why the paths to the two files are not hardcoded. The JavaScript code constructs a directory name from a random number and the current timestamp, represented in base 36, and creates this directory in %TEMP% folder. Then it writes the contents of two large strings it created to files whose names end in 'a' and 'b'. The following excerpt has only the intervening comments removed and the stream operations expanded onto separate lines:

The last three lines explain how the two stages – the JavaScript one and the PowerShell one – fit together. The JavaScript sets variables in its own process environment. And since child processes normally inherit their parent's environment[3], this allows the paths to reach the PowerShell code through the intermediate 'conhost.exe' process.

If we looked at the two files and the remainder of the decoded PowerShell, we would find that the PowerShell code carries the decoding instructions, the environment carries the file paths, and the files themselves carry the encoded payload. The variables do not contain the payload itself, nor does the script persist them as user-wide or machine-wide environment settings. It is “just” an ordinary environment inheritance used to pass information between different stages of an execution chain… Which is nevertheless an interesting approach from a technical standpoint.

It also has a practical consequence for analysis – copying the decoded PowerShell command into an unrelated shell would not be able to recreate the original inputs, and per partes analysis of this infection chain would therefore not be practicable.
In any case, once the strings from the two files were combined and decoded, the PowerShell script would decrypt the resulting value using AES-128-CBC with PKCS#7 padding, using a key and IV that are  included directly in the code:

The decrypted data would then be decompressed using GZipStream.

Reproducing these transformations offline yielded a 315,904-byte, 64-bit .NET executable. The script itself would not save this decoded executable to disk, instead, it would load the resulting byte array as an assembly and invoke its entry point:

For the sake of completeness, it should be mentioned that the two files in the temporary folder are deleted after their contents are read and before the decoding and decryption take place.

This is all that the PowerShell loader stage does, however since we didn’t yet go through everything that the original JavaScript does, let’s get back to it for a moment.

Near the beginning of the script, it attempts to copy itself to %LOCALAPPDATA%\Microsoft\PhotoEngine\PhotoStudio.js, as you can see below.

It then tries to ensure persistence by using the Schedule.Service COM object to attempt to register a task named '\MicrosoftEdgeUpdateTaskCore'.

As you can see, the XML stored in 'v1840' specifies a logon trigger for the current user and an action that would launch 'wscript.exe' with '//B //Nologo' and the copied script's path.

This persistence mechanism is the last part of the JavaScript code we didn’t cover yet, which means we can get back to the .NET executable decoded from the two temporary files.

The executable in question turned out to be another loader. Its reachable code resolves Windows APIs dynamically and attempts to modify code in 'AmsiScanBuffer' and 'AmsiScanString' before loading another assembly, which is an obvious attempt to interfere with AMSI.

It is worth mentioning that the “packaging” of the .NET file was somewhat excessive. Its embedded 299,520 bytes long array does contain the next encrypted executable, but the loader retains only every fifth byte before RC4-decrypting it (i.e., it keeps bytes at offsets 0, 5, 10, etc., and drops everything else). Reproducing that transformation yields a second, 59,904-byte .NET executable.

This executable adds a network dependency to the chain, and decoding its configuration reveals the following download location:

hxxps[:]//yapw[.]life/phpt/stego_zrgaixkku8.png

At the time of writing, the URL was no longer live, nevertheless, from the rest of the .NET code, we can see what would have happened to the downloaded file.

Surprisingly, the file would have been a PNG, and not an executable with fake extension. The downloader would walk the PNG structure and look for an 'iTXt' chunk. PNG defines 'iTXt' as a container for international textual data[4], however instead of this information, the loader would expect to find the final payload there.

Within the data from the aforementioned chunk, it would search for the marker 'FF 89 AD 4A', read an appropriate payload length, apply an XOR-based decryption, and decompress the result using DEFLATE. It expects the recovered bytes to begin with 'MZ', which is – of course – unsurprising…

After recovering the PE file from the PNG, the loader determines whether it is a managed .NET assembly or a native executable and selects the appropriate execution method. Managed assemblies are loaded directly from memory using .NET reflection, while native executables are executed using a process-hollowing routine. Nevertheless, since I was unable to get my hands on the PNG file, it is unclear both which path would have been taken by the downloader, as well as what malware family the final payload would have belonged to…

Although there are several interesting layers to this sample, the small handoff between JavaScript and PowerShell using temporary files and process environment variables seems particularly noteworthy and provides a useful lesson in inter-process data sharing. Thanks to the use of this mechanism, a decoded command line could tell us what the next stage is supposed to do without containing everything it needs to do it…

[1] https://www.virustotal.com/gui/file/408b2df6e81824fa5bdf4f0fbd185a7e6db06e2be98fbeebce416f66954b9fa9
[2] https://isc.sans.edu/diary/Passive+analysis+of+a+phishing+attachment/29798
[3] https://learn.microsoft.com/en-us/windows/win32/procthread/environment-variables
[4] https://www.w3.org/TR/png-3/#11iTXt

 

IoCs

Files

PO.4843293191 For Supply Chain - Imports HM..js
MD5: 7acd5c5f1689332615c03357e143f51e
SHA-256: 408b2df6e81824fa5bdf4f0fbd185a7e6db06e2be98fbeebce416f66954b9fa9

First .NET loader - 315,904 bytes
MD5: 5d92d1fb5d5fbd79a588f22e994a4aff
e4130bf8769a50106a963b6a43dfd4fe5b56c70eae76a0de971d25993159acfe

Second .NET downloader - 59,904 bytes
MD5: f351968c76eefc80d4e292a3f179b7b9
SHA-256: be73e8b06c4356b5b4644d69b4f426bb3b32b4bf9f14cc5743f17532799f760b

URL

hxxps://yapw[.]life/phpt/stego_zrgaixkku8.png

 

TTPs

T1566.001 - Phishing: Spearphishing Attachment – Purchase-quotation lure carrying an archive with malicious JavaScript
T1204.002 - User Execution: Malicious File – Intended execution of the extracted script by the recipient
T1059.007 - Command and Scripting Interpreter: JavaScript – Windows Script Host executes JavaScript file
T1059.001 - Command and Scripting Interpreter: PowerShell – JavaScript constructs and executes a PowerShell command
T1053.005 - Scheduled Task/Job: Scheduled Task – Creation of logon task named 'MicrosoftEdgeUpdateTaskCore'
T1036.004 - Masquerading: Masquerade Task or Service – Creation of logon task named 'MicrosoftEdgeUpdateTaskCore'
T1564.003 - Hide Artifacts: Hidden Window – Hidden WScript.Shell launch, hidden PowerShell window, conhost invoked with '--headless'
T1027.009 - Obfuscated Files or Information: Embedded Payloads – Embedded assemblies
T1027.013 - Obfuscated Files or Information: Encrypted/Encoded File – Multiple obfuscation techniques including use of Base64, AES and RC4
T1027.015 - Obfuscated Files or Information: Compression – Use of GZip, DEFLATE
T1027.016 - Obfuscated Files or Information: Junk Code Insertion – Multiple nonfunctional script expressions
T1140 - Deobfuscate/Decode Files or Information – Runtime decoding, decryption, decompression, and removal of interleaved padding
T1070.004 - Indicator Removal: File Deletion – Delete of two temporary payload-fragment files after use
T1620 - Reflective Code Loading – Use of 'Assembly.Load(byte[])' and entry-point invocation within the current process
T1685 - Disable or Modify Tools – AMSI patching and ETW redirection attempts
T1105 - Ingress Tool Transfer – PNG download
T1027.003 - Obfuscated Files or Information: Steganography – Extraction of payload from PNG metadata
T1055.012 - Process Injection: Process Hollowing – Conditional execution branch for final payload

-----------
Jan Kopriva
LinkedIn
Nettles Consulting

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

Earlier today, I noted an odd request showing up in our "First Seen" report:

GET /PIAF-HMS/ HTTP/1.1
Host: [redacted]
User-Agent: Farez-Sorter/1.0
Accept-Encoding: gzip

This request is linked to a rather old application, a "PBX in a Flash Hospitality Management System" [1]. The last update, the addition of a license file, happened 10 years ago, and I would consider the project abandoned. However, I also noted a new vulnerability reported a couple of months ago: An SQL injection issue. A quick scan of the code shows many more, and the author does not believe in input validation at all. I am also not seeing any authentication and access control, but I have a suspicion that this code may never have been used, and may be intended more as a lab/experiment to test some Asterix PBX integration. With that, I was about to move on.

However, looking at the somewhat odd user agent, I found a few other similar requests:

/admin/
/admin/config.php
/ucp/
/hms/
/hotel/

The scans started yesterday and have been continuing today. The only source IP for the scans is %%ip:94.102.49.125%%. This IP address is associated with IP Volume ( AS202425), which is often considered a bulletproof hoster. Hotels are often "soft targets" for attackers seeking to steal valuable personal data. In some cases, they have been compromised to launch MitM attacks against guests. The focus on PBX systems is interesting, and maybe there are some tricks that could be played on guests if an attacker can appear to call from "inside" the property.

Please let me know if you have some insight as to what is going on here.

[1] https://github.com/claudiopizzillo/PIAF-HMS

--
Johannes B. Ullrich, Ph.D. , Dean of Research, SANS.edu
Twitter|

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

I have not done this type of diary in a while: What traffic will you see from a system on boot, before a user logs in? I just took a quick look at macOS 27 "Golden Gate" to see what traffic you should expect. Here are some of the highlights:

I captured about 300 packets. This was likely inflated for this particular system as it connected via Wi-Fi and wired network interfaces. Each network interface will do its own DHCP/IP discovery during boot. I only used router advertisements for IPv6, not DHCPv6.

IPv6 Neighbor Discovery - Duplicate Address Discovery

As it is supposed to, macOS 27 does standard compliant duplicate address discovery before accepting an IPv6 address. It does use ICMPv6 nonces to prevent some spoofing DoS attacks:

:: > ff02::1:ff8f:bd1c ICMPv6 86  Neighbor Solicitation for fe80::14e5:ff56:308f:bd1c
Internet Control Message Protocol v6
    Type: Neighbor Solicitation (135)
    Code: 0
    Checksum: 0xd8bb [correct]
    [Checksum Status: Good]
    Reserved: 00000000
    Target Address: fe80::14e5:ff56:308f:bd1c
    ICMPv6 Option (Nonce)
        Type: Nonce (14)
        Length: 1 (8 bytes)
        Nonce: 30480a0a9b7c

DNS Traffic

macOS 27 resolved these hostnames during boot:

• _dns.resolver.arpa (SVCB)
  Discover secre (DNS over HTTPS...) DNS resolvers
• 1-courier.push.apple.com???????, 1-courier.sandbox.push.apple.com
  Used for Apple push messaging
• 126.2.5.10.in-addr.arpa
  reverse resolve the local IP address
• albert.apple.com
  This hostname is used by Apple for device activation (do not block it, and it does certificate pinning, so do not TLS intercept it)
• appleid.apple.com
  verifying Apple ID associated with the system
• ipv4only.arpa
  For IPv6-only networks, this record resolves to a NAT64 IPv6 prefix that can be used to reach IPv4-only services. (RFC 7050 and RFC 8880)
• www.apple.com
  Used to discover captive portals.

TCP Options

TCP options have not changed for a few years now in macOS. macOS 27 still uses the somewhat more conservative window scale of "6". It also still uses ECN and random timestamps.

I recorded four TCP connection during boot:

1. TLS to "albert.apple.com" (HTTPS on port 443, IPv4).
2. OCSP connection to ocsp.digicert.com to verify the "albert.apple.com" certificate (HTTP on port 80, IPv6)
3. TLS to "init.push.apple.com" (port 443)
4. TLS connection to courier.push.apple.com (port 5223)

Multicast DNS

Just like prior macOS versions, macOS 27 does advertise any services via multicast DNS on port 5353/udp

User Agents

During boot, the only visible user-agent is contained in the OCSP request: com.apple.trustd/3.0. The user agent is the same as prior versions of macOS. The user agent for Safari is:

Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/27.0 Safari/605.1.15

The version of Safari is indicated as "27.0", but oddly enough, the OS version states "Intel Mac OS X 10_15_7" (this was collected from a Mac with "M" CPU).

--
Johannes B. Ullrich, Ph.D. , Dean of Research, SANS.edu
Twitter|

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

Today, Apple released its annual update across all its operating systems. With that, Apple not only released new features but also patched 261 different vulnerabilities. This is the most vulnerabilities Apple has ever patched, but the increase is not as significant as other vendors' "post-AI" patch releases. 

In addition to the major "27" version, Apple also released bug-fix-only releases for the 26 branch of its operating systems and for 15 (Sequioa) for macOS. None of the vulnerabilities is labeled as being exploited. Apple does not note a severity to individual vulnerabilities.

There are some reports about difficulties downloading iOS 27. Users instead see 26.7 downloaded, but iOS 27 may actually be installed. Also note that some security-relevant applications, such as Little Snitch, have recently released updates that must be applied before upgrading to macOS 27. The Objective-See utility BlockBlock released version 2.5.2 to improve macOS 27 compatiblity.

Figure: Number of patches for each update over the last 2 years.

 

iOS 27 and iPadOS 27	iOS 26.7 and iPadOS 26.7	macOS Golden Gate 27	macOS Tahoe 26.7	macOS Sequoia 15.8	tvOS 27	watchOS 27	visionOS 27
CVE-2022-3437: A user in a privileged network position may be able to leak sensitive user information. Affects Heimdal
		x	x	x
CVE-2026-20683: An app may be able to use the Sign In With Apple authentication flow to access the user's Apple Account. Affects Apple Account
x		x	x	x			x
CVE-2026-28899: An app may bypass Gatekeeper checks. Affects WebDAV
		x	x	x
CVE-2026-28930: An app may be able to access protected user data. Affects Spotlight
				x
CVE-2026-28934: Mounting a malicious disk image may cause unexpected system termination. Affects HFS
		x	x	x
CVE-2026-28935: An app may be able to cause unexpected system termination or corrupt kernel memory. Affects Kernel
				x	x	x	x
CVE-2026-28937: An app may be able to access sensitive user data. Affects Terminal
		x
CVE-2026-28966: Processing a maliciously crafted file may lead to unexpected app termination. Affects RealityKit
x	x	x	x	x	x		x
CVE-2026-28968: An app may be able to cause unexpected system termination or corrupt kernel memory. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-28969: An app may be able to cause unexpected system termination. Affects IOKit
x		x	x	x	x	x	x
CVE-2026-34979: An attacker in a privileged network position may be able to cause a denial-of-service. Affects CUPS
		x
CVE-2026-43661: Processing a maliciously crafted image may corrupt process memory. Affects ImageIO
	x
CVE-2026-43664: An app may be able to access sensitive user data. Affects Accessibility
x	x	x	x	x	x	x
CVE-2026-43674: An attacker with physical access to an unlocked device may be able to view Wi-Fi passwords without authentication. Affects Wi-Fi3
x
CVE-2026-43677: Connecting to a malicious WebDAV server may lead to unexpected app termination. Affects WebDAV
		x	x	x
CVE-2026-43683: An app may be able to cause unexpected process termination or disclose process memory. Affects CoreDrag
		x	x	x
CVE-2026-43684: An app may be able to cause unexpected system termination or corrupt kernel memory. Affects Kernel
	x	x		x
CVE-2026-43686: Connecting to a malicious NFS server may lead to kernel memory corruption. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-43687: Connecting to a malicious NFS server may disclose kernel memory. Affects Kernel
x	x	x	x		x	x	x
CVE-2026-43688: Processing a maliciously crafted file may lead to unexpected app termination. Affects Filters
x		x
CVE-2026-43689: A malicious app may be able to gain root privileges. Affects Kernel
x	x	x					x
CVE-2026-43690: A local user may be able to read kernel memory. Affects SMB
		x	x	x
CVE-2026-43691: An app may be able to gain root privileges. Affects CUPS
		x	x	x
CVE-2026-43692: A remote user may cause an unexpected app termination or arbitrary code execution. Affects CUPS
		x	x	x
CVE-2026-43695: An app may be able to access sensitive user data. Affects NetworkExtension
x		x	x	x	x	x	x
CVE-2026-43696: An app may be able to capture Touch Bar content without authorization. Affects Touch Bar
		x
CVE-2026-43697: Processing a maliciously crafted 3D file may lead to an out-of-bounds read. Affects SceneKit
		x	x	x
CVE-2026-43698: An app may be able to gain root privileges. Affects CUPS
		x	x
CVE-2026-43702: Processing a maliciously crafted video file may lead to unexpected app termination or corrupt process memory. Affects CoreMedia Video Toolbox
	x		x	x
CVE-2026-43715: Processing maliciously crafted web content may lead to memory corruption. Affects WebKit
	x
CVE-2026-43719: Mounting a maliciously crafted SMB network share may lead to system termination. Affects SMB
		x	x	x
CVE-2026-43737: An app may be able to access motion data from headphones without user consent. Affects CoreMotion
x	x	x	x	x	x	x
CVE-2026-43738: Processing a maliciously crafted asset catalog may result in disclosure of process memory. Affects CoreUI
x		x
CVE-2026-43741: An app may be able to access protected user data. Affects Messages
		x	x	x
CVE-2026-43743: An app may be able to cause unexpected system termination. Affects IOGPUFamily
	x		x
CVE-2026-43760: An app may be able to access user-sensitive data. Affects Screen Sharing Server
			x
CVE-2026-43763: An app may be able to read files outside of its sandbox. Affects ATS
			x	x
CVE-2026-43785: An app may be able to modify a file it only had permission to read. Affects File Bookmark
x		x	x	x	x		x
CVE-2026-43786: An app may be able to gain root privileges. Affects CoreServices
		x	x	x
CVE-2026-43787: An attacker in a privileged network position may be able to leak sensitive user information. Affects Mail
		x	x	x
CVE-2026-43788: Processing a maliciously crafted file may lead to a denial-of-service or potentially disclose memory contents. Affects Spotlight
		x
CVE-2026-43789: An app may be able to access user-sensitive data. Affects CoreMedia
		x	x	x
CVE-2026-43790: A remote attacker may be able to cause unexpected system termination or corrupt kernel memory. Affects Kernel
		x	x	x
CVE-2026-43791: An app may be able to read arbitrary files. Affects StorageKit
		x	x	x
CVE-2026-43794: Processing maliciously crafted web content may lead to memory corruption. Affects WebKit
					x	x	x
CVE-2026-64712: An app may be able to gain root privileges. Affects odproxyd
		x	x	x
CVE-2026-64714: Processing a maliciously crafted image may lead to a denial-of-service. Affects ImageIO
		x
CVE-2026-64715: Processing maliciously crafted web content may lead to an unexpected process crash. Affects WebKit
					x	x	x
CVE-2026-64718: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit Canvas
x	x	x					x
CVE-2026-64736: An app may be able to cause unexpected system termination or corrupt kernel memory. Affects IOMobileFrameBuffer
				x	x	x	x
CVE-2026-64752: Processing a maliciously crafted image may lead to arbitrary code execution. Affects CoreMedia
x		x					x
CVE-2026-64753: Processing maliciously crafted web content may disclose sensitive user information. Affects WebKit
x		x			x	x	x
CVE-2026-64756: An app may be able to access user-sensitive data. Affects Image Capture
x		x	x	x
CVE-2026-64758: Processing a maliciously crafted file may lead to unexpected app termination. Affects ImageIO
	x			x
CVE-2026-64760: An app may be able to leak sensitive kernel state. Affects IOSurfaceAccelerator
x		x			x	x	x
CVE-2026-64761: An app may be able to identify what other apps a user has installed. Affects Accessibility
x
CVE-2026-64778: Visiting a maliciously crafted website may leak sensitive data. Affects WebKit History
					x	x	x
CVE-2026-64779: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit Storage
							x
CVE-2026-64780: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit
							x
CVE-2026-64781: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit
							x
CVE-2026-64782: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit
							x
CVE-2026-64784: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit
							x
CVE-2026-64787: Processing maliciously crafted web content may lead to an unexpected process termination. Affects WebKit
					x	x	x
CVE-2026-64788: Processing maliciously crafted web content may lead to memory corruption. Affects IOGPUFamily
						x	x
CVE-2026-64790: An app may be able to gain elevated privileges. Affects CUPS
		x	x	x
CVE-2026-65329: An attacker in a privileged network position may be able to bypass IPSec authentication and intercept network traffic. Affects Telephony
x
CVE-2026-65331: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit
							x
CVE-2026-65334: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit
							x
CVE-2026-65338: Processing maliciously crafted web content may lead to an unexpected Safari crash. Affects WebKit
							x
CVE-2026-65339: An app may be able to leak sensitive user information. Affects Audio
				x	x	x	x
CVE-2026-65341: Processing maliciously crafted web content may lead to memory corruption. Affects WebKit
					x	x	x
CVE-2026-65342: An app may be able to access sensitive user data. Affects ATS
		x	x	x
CVE-2026-65343: A remote attacker may be able to cause unexpected system termination. Affects Kernel
					x	x	x
CVE-2026-65344: Processing a maliciously crafted video file may lead to unexpected app termination. Affects CoreMedia
x	x	x	x	x	x		x
CVE-2026-65345: An app may be able to access user-sensitive data. Affects Storage
x	x	x	x	x
CVE-2026-65346: Processing an image may lead to arbitrary code execution. Affects ImageIO
				x	x	x	x
CVE-2026-65347: Processing an image may lead to a denial-of-service. Affects ImageIO
					x	x	x
CVE-2026-65348: An app may be able to modify protected parts of the file system. Affects Storage
x	x	x	x	x
CVE-2026-65349: An app may be able to cause unexpected system termination or read kernel memory. Affects Kernel
				x	x	x	x
CVE-2026-65354: A malicious app may be able to break out of its sandbox. Affects iWork
x		x
CVE-2026-65358: An app may be able to cause unexpected system termination. Affects Kernel
x		x		x	x	x	x
CVE-2026-65359: A local user may be able to cause unexpected system termination or read kernel memory. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-65360: An app may be able to cause unexpected system termination. Affects Kernel
	x
CVE-2026-65361: An app may be able to access sensitive user data. Affects SoftwareUpdate
		x	x	x
CVE-2026-65362: An app may be able to gain root privileges. Affects Disk Images
		x	x	x
CVE-2026-65364: A remote attacker may be able to cause unexpected system termination. Affects Kernel
		x	x	x
CVE-2026-65365: Connecting to a malicious SMB share may disclose kernel memory. Affects SMB
		x	x	x
CVE-2026-65369: A malicious application may bypass Gatekeeper checks. Affects Kernel
		x	x	x
CVE-2026-65371: An app may be able to disclose kernel memory. Affects Kernel
				x
CVE-2026-65374: Connecting to a malicious WebDAV server may result in code execution. Affects WebDAV
		x	x	x
CVE-2026-65375: An app may be able to cause unexpected system termination. Affects WebDAV
		x		x
CVE-2026-65376: An app may be able to cause unexpected system termination. Affects SMB
		x	x	x
CVE-2026-65377: An app may be able to cause unexpected system termination. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-65378: An app may be able to access sensitive user data. Affects Spotlight
		x	x	x
CVE-2026-65380: An app may be able to access protected user data. Affects Sandbox
		x
CVE-2026-65381: A malicious app may be able to break out of its sandbox. Affects AppleMobileFileIntegrity
		x	x	x
CVE-2026-65382: An app may be able to access sensitive user data. Affects LaunchServices
		x	x	x
CVE-2026-65383: An app may bypass Gatekeeper checks. Affects System Settings
		x
CVE-2026-65390: Processing maliciously crafted web content may lead to memory corruption. Affects WebRTC
					x	x	x
CVE-2026-65391: Processing maliciously crafted web content may lead to memory corruption. Affects WebRTC
					x	x	x
CVE-2026-65393: An app may be able to access user-sensitive data. Affects Xcode IDE
		x
CVE-2026-65395: Processing a maliciously crafted image may result in memory corruption. Affects ImageIO
x	x	x	x	x	x		x
CVE-2026-65398: An app may be able to cause unexpected system termination or corrupt kernel memory. Affects IOMobileFrameBuffer
x		x
CVE-2026-65399: An archive may be able to bypass Gatekeeper. Affects copyfile
x	x	x	x	x		x	x
CVE-2026-65400: An attacker on the network may be able to authenticate to Screen Sharing without valid credentials. Affects Screen Sharing Server
		x	x
CVE-2026-65401: An app may be able to cause unexpected system termination. Affects Kernel
			x
CVE-2026-65402: An app may be able to cause unexpected system termination. Affects Kernel
x		x			x	x	x
CVE-2026-65403: An app may be able to access sensitive user data. Affects Reminders
x	x	x	x	x		x	x
CVE-2026-65404: A malicious application may be able to bypass Privacy preferences. Affects Accounts
x		x
CVE-2026-65405: An app may be able to determine kernel memory layout. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-65406: An app may be able to access sensitive user data. Affects BackgroundAssets
x	x	x	x	x	x		x
CVE-2026-65407: An app may be able to cause unexpected system termination. Affects AppleAVD
x	x	x	x	x	x	x	x
CVE-2026-65408: An app may be able to cause unexpected system termination. Affects Apple Neural Engine
x	x	x	x	x
CVE-2026-65409: An app may be able to cause a denial of service. Affects Foundation
x	x	x	x	x	x	x	x
CVE-2026-65410: An app may be able to cause unexpected system termination. Affects AVEVideoEncoder
x	x	x	x		x	x	x
CVE-2026-65411: An app may be able to modify protected parts of the file system. Affects MobileBackup
x	x						x
CVE-2026-65412: Processing web content may lead to a denial-of-service. Affects CoreText
x	x	x	x	x		x	x
CVE-2026-65413: An app may be able to cause a denial of service. Affects SceneKit
		x	x	x
CVE-2026-65415: A local user may be able to cause unexpected system termination or read kernel memory. Affects Kernel
x		x			x	x	x
CVE-2026-84487: Processing a maliciously crafted file may result in disclosure of process memory. Affects SceneKit
x	x	x	x	x	x	x	x
CVE-2026-84489: An app may be able to cause a denial of service. Affects CoreUI
x		x
CVE-2026-84491: An app may be able to access sensitive user data. Affects Photos Storage
x	x	x			x	x	x
CVE-2026-84492: An app may be able to cause unexpected system termination. Affects Graphics
x	x	x	x	x	x	x	x
CVE-2026-84497: Opening a maliciously crafted file may lead to unexpected process termination. Affects Model I/O
x	x	x	x	x	x		x
CVE-2026-84505: An app may be able to gain root privileges. Affects Directory Utility
		x	x	x
CVE-2026-84506: An app may be able to execute arbitrary code with kernel privileges. Affects udf
		x	x	x
CVE-2026-84507: An app may be able to cause unexpected system termination or corrupt kernel memory. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-84509: Connecting to a malicious SMB server may lead to unexpected system termination. Affects SMB
		x	x	x
CVE-2026-84510: Mounting a maliciously crafted volume may lead to unexpected system termination. Affects exFAT
x	x	x	x	x
CVE-2026-84511: Processing a maliciously crafted asset catalog may lead to unexpected process termination. Affects CoreUI
x		x	x	x	x	x	x
CVE-2026-84512: Mounting a maliciously crafted disk image may cause unexpected system termination or corrupt kernel memory. Affects Disk Images
		x	x	x
CVE-2026-84513: A malicious application may be able to determine a user's current location. Affects Symptom Framework
x	x	x	x	x	x	x	x
CVE-2026-84514: An app may be able to modify protected parts of the file system. Affects Kext Management
		x	x	x
CVE-2026-84515: Connecting to a malicious SMB server may lead to kernel memory corruption. Affects SMB
		x	x	x
CVE-2026-84516: Processing a maliciously crafted file may result in unexpected app termination or disclosure of process memory. Affects CUPS
		x	x	x
CVE-2026-84517: An app may be able to cause unexpected system termination. Affects Kernel
		x	x	x
CVE-2026-84518: A malicious website may be able to determine what apps a user has installed. Affects Safari
x		x
CVE-2026-84519: Mounting a disk image with maliciously crafted files may lead to unexpected system termination. Affects AppleDouble
x	x	x	x	x
CVE-2026-84520: A local attacker may be able to cause unexpected system termination or corrupt kernel memory. Affects AppleFDEKeyStore
		x
CVE-2026-84521: An app may be able to cause unexpected system termination. Affects Kernel
	x		x	x
CVE-2026-84522: An app may be able to access sensitive user data. Affects Archive Utility
		x
CVE-2026-84523: An app may be able to cause unexpected system termination or write kernel memory. Affects APFS
x	x	x	x	x	x	x	x
CVE-2026-84524: Processing a maliciously crafted font file may lead to unexpected app termination. Affects FontParser
x	x	x	x	x	x	x	x
CVE-2026-84525: An app may be able to access user-sensitive data. Affects ATS
		x	x	x
CVE-2026-84526: Processing a maliciously crafted 3D scene may lead to unexpected process termination. Affects SceneKit
x	x	x	x	x	x	x	x
CVE-2026-84527: An app may be able to access sensitive user data. Affects TCC
x		x	x	x	x	x	x
CVE-2026-84530: An app may be able to disclose kernel memory. Affects Kernel
x	x	x	x		x	x	x
CVE-2026-84531: Processing maliciously crafted NTLM input may lead to unexpected app termination. Affects Security
x		x
CVE-2026-84532: Opening a maliciously crafted file may cause unexpected process termination or disclose process memory. Affects RealityKit
x	x	x	x	x	x		x
CVE-2026-84533: An attacker in a privileged network position may be able to modify network traffic. Affects Heimdal
x		x			x	x
CVE-2026-84534: Extracting a maliciously crafted archive may allow an attacker to write arbitrary files. Affects file_cmds
x	x	x	x	x			x
CVE-2026-84535: An app may be able to break out of its sandbox. Affects Automator
		x	x	x
CVE-2026-84536: Connecting to a malicious SMB server may lead to unexpected system termination. Affects SMB
		x	x	x
CVE-2026-84537: An app may be able to cause unexpected system termination or corrupt kernel memory. Affects SMB
		x	x	x
CVE-2026-84538: A remote attacker may be able to cause a denial-of-service. Affects Kernel
		x	x	x
CVE-2026-84540: An app may be able to access sensitive user data. Affects CUPS
		x	x	x
CVE-2026-84541: An application may be able to access restricted files. Affects CUPS
		x	x	x
CVE-2026-84543: Connecting to a malicious SMB server may cause unexpected system termination or corrupt kernel memory. Affects SMB
		x	x	x
CVE-2026-84544: Connecting to a malicious NFS server may cause unexpected system termination or corrupt kernel memory. Affects Kernel
		x	x	x
CVE-2026-84548: Processing a maliciously crafted document may lead to an out-of-bounds read. Affects Quick Look
		x	x	x
CVE-2026-84549: Connecting to a malicious NFS server may cause unexpected system termination or corrupt kernel memory. Affects Kernel
		x	x	x
CVE-2026-84550: An app may be able to cause unexpected system termination. Affects Disk Images
		x	x	x
CVE-2026-84551: An app may be able to bypass network restrictions. Affects Sandbox
x		x				x	x
CVE-2026-84552: An app may be able to cause unexpected system termination. Affects Disk Images
x	x	x	x	x
CVE-2026-84553: A remote attacker may be able to cause a denial-of-service. Affects smbx
		x	x	x
CVE-2026-84554: An attacker in a privileged network position may be able to cause a denial-of-service. Affects CUPS
		x	x	x
CVE-2026-84555: An app may be able to access sensitive user data. Affects Sandbox
		x		x
CVE-2026-84556: An app may be able to access sensitive user data. Affects Keychain Access
		x	x	x
CVE-2026-84558: An app may be able to cause unexpected system termination. Affects Kernel
		x
CVE-2026-84559: A malicious application may be able to access restricted files. Affects CoreServices
		x	x	x
CVE-2026-84560: An app may gain unauthorized access to Bluetooth. Affects Bluetooth
x		x			x	x	x
CVE-2026-84561: An app may be able to cause unexpected system termination or corrupt kernel memory. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-84563: An app may be able to cause unexpected system termination. Affects CUPS
		x	x	x
CVE-2026-84564: Processing a maliciously crafted image may result in disclosure of process memory. Affects ImageIO
x	x	x	x	x	x	x	x
CVE-2026-84565: Processing a maliciously crafted disk image may lead to unexpected app termination. Affects Disk Images
		x	x	x
CVE-2026-84566: A local attacker may be able to cause unexpected system termination or corrupt kernel memory. Affects Kernel
x	x	x	x	x
CVE-2026-84567: An app may be able to cause unexpected system termination. Affects cd9660
		x	x	x
CVE-2026-84568: An attacker with control of a network directory server may be able to execute arbitrary code with root privileges. Affects autofs
		x	x	x
CVE-2026-84569: An app may be able to access sensitive user data. Affects Foundation
		x
CVE-2026-84570: An app may be able to bypass Gatekeeper checks. Affects autofs
		x	x	x
CVE-2026-84571: Processing a maliciously crafted image may lead to unexpected app termination. Affects CoreUI
x		x			x	x	x
CVE-2026-84572: An app may be able to cause unexpected system termination or read kernel memory. Affects udf
		x	x	x
CVE-2026-84573: An app may be able to access sensitive user data. Affects Mail
		x	x	x
CVE-2026-84574: An app may be able to bypass Privacy preferences. Affects CoreServices
		x	x	x
CVE-2026-84575: Processing a maliciously crafted file may lead to unexpected app termination. Affects CoreUI
x		x	x	x	x	x	x
CVE-2026-84576: An app may be able to access sensitive user data. Affects QuartzCore
		x	x	x
CVE-2026-84577: An app may be able to bypass sandbox restrictions. Affects libxpc
		x	x
CVE-2026-84578: An app may be able to break out of its sandbox. Affects quarantine
		x	x	x
CVE-2026-84580: An app may be able to break out of its sandbox. Affects quarantine
		x	x	x
CVE-2026-84581: Mounting a maliciously crafted disk image may cause unexpected system termination or corrupt kernel memory. Affects HFS
		x	x	x
CVE-2026-84583: A local app may be able to read a persistent account identifier. Affects AuthKit
x	x	x	x	x	x	x	x
CVE-2026-84584: An app may be able to break out of its sandbox. Affects Archive Utility
		x
CVE-2026-84585: An app may be able to access local network devices without user consent. Affects NetworkExtension
		x
CVE-2026-84586: A malicious application may be able to leak sensitive user information. Affects Apple Account
		x				x
CVE-2026-84587: An app may be able to access protected user data. Affects AppKit
		x	x	x
CVE-2026-84588: Mounting a maliciously crafted disk image may cause unexpected system termination or corrupt kernel memory. Affects Kernel
		x
CVE-2026-84589: An app may be able to modify Privacy preferences. Affects TCC
		x
CVE-2026-84593: An app may be able to cause unexpected system termination. Affects AppleKeyStore
x
CVE-2026-84596: Processing a maliciously crafted font may result in the disclosure of process memory. Affects CoreText
x		x			x	x	x
CVE-2026-84597: Processing a maliciously crafted font may result in the disclosure of process memory. Affects FontParser
x		x			x	x	x
CVE-2026-84598: An attacker with physical access to a trust-paired device may be able to read and write arbitrary files. Affects MobileBackup
x	x
CVE-2026-84600: A malicious shortcut may be able to send messages without user confirmation. Affects Shortcuts
x		x			x	x	x
CVE-2026-84601: An app may be able to bypass Apple Intelligence security prompts. Affects Apple Intelligence
		x
CVE-2026-84602: An app may be able to cause unexpected system termination. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-84603: An app may be able to access sensitive user data. Affects Sandbox Profiles
x						x	x
CVE-2026-84606: An app may be able to identify a user across reinstalls. Affects iCloud
x		x					x
CVE-2026-84607: A sandboxed app may be able to execute arbitrary code with kernel privileges. Affects AVEVideoEncoder
x	x	x	x	x	x	x	x
CVE-2026-84609: An app may be able to modify protected system files. Affects Software Update
x		x	x	x	x	x	x
CVE-2026-84611: Processing a maliciously crafted 3D model may lead to memory corruption. Affects SceneKit
x	x	x	x	x	x	x	x
CVE-2026-84612: An app may be able to read persistent device identifiers. Affects DeviceCheck
x	x	x	x	x	x	x	x
CVE-2026-84615: An app may be able to access sensitive user data. Affects Music
x	x				x		x
CVE-2026-84616: An app may be able to cause unexpected system termination. Affects AVEVideoEncoder
x	x	x	x	x	x	x	x
CVE-2026-84617: An app may be able to access sensitive user data. Affects XPC
x	x	x	x	x	x
CVE-2026-84618: An app may be able to access sensitive user data. Affects Game Center
		x	x	x
CVE-2026-84619: An app may be able to cause unexpected system termination or write kernel memory. Affects Kernel
		x	x	x
CVE-2026-84620: Processing a maliciously crafted 3D model may lead to memory corruption. Affects SceneKit
x	x	x	x	x	x	x	x
CVE-2026-84621: An app may be able to access sensitive user data. Affects Spotlight
x	x	x	x	x
CVE-2026-84622: An app with root privileges may be able to read uninitialized kernel memory. Affects Kernel
x	x	x	x	x	x	x	x
CVE-2026-84623: An app may be able to fingerprint the device. Affects Power Management
x	x
CVE-2026-84624: A sandboxed app may be able to access restricted files. Affects CoreML
x	x	x	x	x			x
CVE-2026-84625: An app may be able to fingerprint the user. Affects Sandbox Profiles
x		x				x	x
CVE-2026-84626: An app may be able to identify what other apps a user has installed. Affects NetworkExtension
x	x	x	x	x	x	x	x
CVE-2026-84628: A sandboxed app may be able to access the System Keychain. Affects MediaRemote
x		x			x	x	x
CVE-2026-84629: An app may be able to fingerprint the user. Affects Photos Storage
x					x	x	x
CVE-2026-84631: An app may be able to gain root privileges. Affects Bluetooth
		x
CVE-2026-84632: Processing a maliciously crafted 3D model may lead to memory corruption. Affects SceneKit
x	x	x	x	x	x	x	x
CVE-2026-84635: Processing maliciously crafted web content may lead to an unexpected process termination. Affects WebKit
x		x			x	x	x
CVE-2026-84636: An app may be able to access sensitive user data. Affects Wi-Fi Connectivity
x					x	x	x
CVE-2026-86869: Processing a maliciously crafted image may lead to unexpected app termination. Affects ImageIO
	x	x
CVE-2026-86870: Processing a maliciously crafted file may lead to unexpected app termination. Affects libarchive
x	x	x				x	x
CVE-2026-86876: A sandboxed process may be able to circumvent sandbox restrictions. Affects CoreMedia
x	x	x	x	x		x	x
CVE-2026-86878: An app may be able to access sensitive user data. Affects Camera
x
CVE-2026-86879: A remote attacker may be able to cause a denial-of-service. Affects Baseband
x
CVE-2026-86881: An attacker with a compromised intermediate certificate authority may be able to issue certificates with arbitrary extended key usages. Affects Security
x	x	x	x	x	x	x	x
CVE-2026-86882: Processing a maliciously crafted image may lead to unexpected process termination. Affects Accelerate Framework
x	x	x	x	x	x	x	x
CVE-2026-86883: An app may be able to access sensitive user data. Affects Managed Configuration
x							x
CVE-2026-86884: An app may be able to access sensitive user data. Affects Siri
x		x			x	x
CVE-2026-86885: An attacker in radio range may be able to cause unexpected system termination. Affects Baseband
x
CVE-2026-86886: An app may be able to modify protected system files. Affects TCC
x	x					x
CVE-2026-86887: An app may be able to bypass certain Privacy preferences. Affects Time Zone
x	x						x
CVE-2026-86888: A local app may be able to read a persistent account identifier. Affects App Store
x		x	x		x	x	x
CVE-2026-86889: An attacker in a privileged network position may be able to intercept network traffic. Affects Security
		x	x	x
CVE-2026-86890: An attacker with physical access to a locked device may be able to view sensitive user information. Affects Siri Suggestions
x	x
CVE-2026-86891: An app may be able to access Bluetooth device information. Affects Core Bluetooth
		x	x	x		x
CVE-2026-86892: An app may be able to cause a denial-of-service. Affects SpringBoard
x	x						x
CVE-2026-86893: An app may be able to read device name. Affects CloudKit
x					x	x	x
CVE-2026-86894: An app may be able to break out of its sandbox. Affects libxpc
		x
CVE-2026-86895: A local app may be able to read a persistent account identifier. Affects CloudKit
x					x	x	x
CVE-2026-86897: An app may be able to access sensitive user data. Affects Safe Browsing
x	x	x					x
CVE-2026-86898: Opening a maliciously crafted webarchive file may lead to universal cross-site scripting. Affects WebKit
x		x					x
CVE-2026-86900: Mounting a maliciously crafted exFAT volume may cause unexpected system termination or kernel memory disclosure. Affects exFAT
		x
CVE-2026-86901: Mounting a maliciously crafted exFAT volume may cause unexpected system termination or kernel memory disclosure. Affects exFAT
		x
CVE-2026-86902: An app may be able to access sensitive user data. Affects NSDocument
		x
CVE-2026-86903: An app may be able to disclose kernel memory. Affects Kernel
x		x			x	x	x
CVE-2026-86904: An app may be able to track users across apps and websites without permission. Affects Watch App
x	x					x
CVE-2026-86905: An app may be able to delete credentials stored in Keychain. Affects Authentication Services
x		x					x
CVE-2026-86909: An app may be able to bypass Gatekeeper checks. Affects System Settings
		x
CVE-2026-86910: An application may be able to access restricted files. Affects APFS
		x	x	x
CVE-2026-86911: A malicious app may be able to bypass clickjacking protections for secure prompts. Affects Foundation
		x
CVE-2026-86917: An app may be able to gain root privileges. Affects Kernel
		x	x	x
CVE-2026-86924: Connecting a malicious accessory may cause unexpected system termination. Affects MobileAccessoryUpdater
x	x	x	x

--
Johannes B. Ullrich, Ph.D. , Dean of Research, SANS.edu
Twitter|

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.