<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by VXRL on Medium]]></title>
        <description><![CDATA[Stories by VXRL on Medium]]></description>
        <link>https://medium.com/@vxrl?source=rss-ac8a64f61467------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*QrGjAiqew775OJ18Fccujw.jpeg</url>
            <title>Stories by VXRL on Medium</title>
            <link>https://medium.com/@vxrl?source=rss-ac8a64f61467------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 09:59:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@vxrl/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[PHP2Shell]]></title>
            <link>https://vxrl.medium.com/php2shell-bfa0d8db5e84?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/bfa0d8db5e84</guid>
            <category><![CDATA[php2shell]]></category>
            <category><![CDATA[exploitation]]></category>
            <category><![CDATA[rce]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 17:49:54 GMT</pubDate>
            <atom:updated>2026-10-22T01:12:50.624Z</atom:updated>
            <content:encoded><![CDATA[<p><em>CVE-2026–109618 &amp; CVE-2026–109619 — pre-auth RCE in PHP core, explained for the rest of the team.</em></p><p>Researchers: {VXRL Team}</p><p>On October 21, 2026 the PHP team shipped an emergency release. Behind it were two CVEs — CVE-2026–109618 and CVE-2026–109619 — that researchers at Calif.io, Wiz, and OpenAI are calling <em>PHP2Shell</em>. The headline from Wiz says it all:</p><blockquote>“Every PHP version released in the last decade is affected by at least one of these vulnerabilities.”</blockquote><p>Both are rated Critical (CVSS 9.2). Both are pre-authentication. Both were demonstrated as remote code execution against stock WordPress, Drupal, and Joomla. The bug reaches back to PHP 5.4 (2012).</p><p>If you run PHP — and if you run WordPress, you run PHP — this is a “patch today” event. This post explains <em>why</em> it’s so bad, at the level of mechanism and defense. It does not contain a weaponized exploit; the researchers deliberately withheld that, and so do we.</p><h3>The one idea behind all of it</h3><p>PHP serves many HTTP requests from one long-lived worker process (Apache mod_php, or a PHP-FPM pool worker). Each request gets its own request heap, set up at <em>request startup</em> and torn down at <em>request shutdown</em>.</p><p>Every PHP2Shell bug is the same shape:</p><blockquote><em>An exceptional control-flow path — an out-of-memory (OOM) error, or any fatal error — jumps out of an operation </em>before it finished setting up or tearing down its state<em>. That leaves a pointer referring to memory that is uninitialized or already freed. Later code then reads or branches on that pointer.</em></blockquote><p>PHP implements OOM with a longjmp() — a non-local jump that abandons whatever it was doing. That&#39;s the trapdoor. Land an allocation failure at the wrong moment and you leave the engine holding a dangling reference.</p><h3>Four bugs, one lever</h3><p>Wiz decomposes the two CVEs into four distinct bugs. They all start from the same lever — <em>force an OOM/fatal at a moment you choose</em> — and differ only in which global ends up dangling:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rUn8n1AIUCMsevUL_Z3IeA.png" /></figure><p>Bug #2 is the one people ask about when they say <em>“can it read my files?”</em> It’s a memory read, not a filesystem read — but it leaks whatever is in the reclaimed heap: other users’ request data, session contents, secrets sitting in process memory — and it URL-encodes them straight into a response cookie. The published RCE chain combined #1 + #2: leak with #2, then drive the unserializer UAF in #1 to execution.</p><h3>Stage 1: forcing an out-of-memory error on demand</h3><p>Every one of those bugs needs the same primitive first: make a chosen allocation fail at a chosen time, without tripping any size limit. This is the part the writeups describe publicly, so it’s the part our lab reproduces.</p><p>Two tricks combine.</p><p>1. Slip past post_max_size. PHP checks that limit against the request&#39;s <em>declared</em> Content-Length, not the bytes it actually consumes. Send the body with HTTP chunked transfer encoding (no declared length) and the initial check is simply skipped.</p><p>2. Amplify memory inside a tiny body. Modern PHP caps the <em>number</em> of multipart parts (max_multipart_body_parts, default 1020) — but it does not cap the number of header lines inside a single part, and it holds them all in memory while parsing that part. In our lab we measured ~320 bytes of PHP heap retained per header line. So one part with ~300,000 cheap header lines is ~4 MiB on the wire but drives ~96 MiB of allocation — blowing a 64 MiB memory_limit.</p><p>The generator is boring on purpose:</p><pre>for p in range(parts):                      # parts: keep &lt; 1020<br>    out += b&quot;--&quot; + boundary + CRLF<br>    out += b&#39;Content-Disposition: form-data; name=&quot;f%d&quot;; filename=&quot;&quot;&#39; % p + CRLF<br>    out += b&quot;Content-Type: application/octet-stream&quot; + CRLF<br>    for h in range(headers):                 # headers: the UNCAPPED amplifier<br>        out += b&quot;X-P%d: x&quot; % h + CRLF        # ~320 bytes of PHP heap each<br>    out += CRLF + CRLF</pre><p>And the request:</p><pre>curl -X POST -H &#39;Transfer-Encoding: chunked&#39; \<br>     -H &#39;Content-Type: multipart/form-data; boundary=sep&#39; \<br>     --data-binary @body.bin  http://victim/wp-login.php</pre><p>The result, against PHP 8.4.26:</p><pre>PHP Fatal error:  Allowed memory size of 67108864 bytes exhausted<br>                  (tried to allocate 4096 bytes) in Unknown on line 0</pre><p>&quot;Unknown on line 0&quot; is the tell: the fatal fires during request-startup parsing, before any application code runs — exactly where the vulnerable state lives. The application never got a say. Add a PHP_SESSION_UPLOAD_PROGRESS field and a session cookie and you&#39;ve engaged the session path behind CVE-2026-109619.</p><h3>mod_php and PHP-FPM react differently</h3><p>A common question is “we run PHP-FPM, not mod_php — are we fine?” Not exactly, but the two SAPIs behave differently, and it’s worth being precise. Our lab runs both — Apache mod_php and nginx + PHP-FPM — and fires the identical ~4 MiB request at each:</p><pre>TARGET               | HTTP | WHAT HAPPENS NEXT<br> mod_php(vuln)        | 500  | OOM fatal forced; worker SURVIVES &amp; is reused<br> nginx+fpm(vuln)      | 502  | OOM fatal forced; FPM child EXITS (code 70) &amp; is replaced</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/884/1*pVfiIys56EOQaGd6fKBYBA.gif" /></figure><p>The OOM fires on both. The difference is the aftermath, and it’s the whole game. On mod_php the worker survives the fatal and serves the next request — in the lab the Apache worker PID is identical before and after:</p><pre>worker_pid= 22      &lt;- before the OOM fatal<br>worker_pid= 22      &lt;- after: worker SURVIVED &amp; REUSED</pre><p>Request A leaves a global pointing into its freed heap; request B — <em>your next request, on the same worker</em> — walks that stale pointer. That reused worker is exactly the window CVE-2026–109619 abuses, and it’s the path the advisories demonstrate app-independently.</p><p>On PHP-FPM the child that handled the fatal exits and is recycled, so this particular request-<em>startup</em> sequence doesn’t survive to be consumed. FPM is still listed as susceptible by both CVEs — but via a <em>separate, application-dependent</em> path (state published during normal request execution, then consumed by upload progress), which the researchers did not fully detail and this lab does not reproduce. So: FPM is not immune, but “fire a startup OOM and win” is a mod_php story.</p><h3>So… does it really get a shell?</h3><p>Yes. This is confirmed, demonstrated, pre-auth remote code execution — not a theoretical “maybe.” The CVE-2026–109618 advisory states full unauthenticated RCE was validated over HTTP against mod_php with default input and memory limits; Calif and Wiz report pre-auth RCE against stock WordPress, Drupal and Joomla.</p><p>The honest caveats: it’s rated AC:H / AT:P — high complexity, special conditions. Success depends on heap grooming landing correctly and defeating ASLR; it&#39;s &quot;run it until it wins,&quot; not a guaranteed one-shot.</p><p>We verified this ourselves under controlled laboratory conditions: a stock php:8.4.26-apache image with display_errors=On, memory_limit=8M, and a single-worker Apache prefork. Under those settings the full chain — heap leak, ASLR bypass, fake zend_reference placement, zif_system execution — completes in seconds over plain HTTP, against a page that contains nothing but &lt;?php echo &quot;OK\n&quot;; ?&gt;:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*IqwXJfpvcTjQRn6FhwYvKQ.gif" /></figure><p>Not all PHP servers are exploitable with these exact steps. The demonstration requires non-default settings (display_errors=On, memory_limit=8M, KeepAlive Off, single worker, mod_php, linux/amd64) that make heap grooming deterministic. A real-world exploit would need to handle production configurations, multi-worker environments, and different ASLR layouts. The severity is real — the researchers demonstrated RCE against stock WordPress, Drupal, and Joomla — but &quot;fire one script and always win&quot; is not how it works in the wild.</p><p>The difficulty is in <em>writing</em> the exploit. Whether a shell is achievable is settled: it is. In our lab, the same RCE chain plants a webshell on the victim and drops into an interactive command loop — www-data on the box, all pre-auth, all over ordinary HTTP POST requests.</p><p>Actual Exploit Demo: (<a href="https://www.youtube.com/watch?v=5oEa2Y_CL1Q">https://www.youtube.com/watch?v=5oEa2Y_CL1Q</a>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*wJfwfbTWVpRdaOSFbGwylA.gif" /></figure><h3>Lab setup vs. the real world</h3><p>Our lab pins every knob to make heap grooming deterministic: display_errors=On so a warning flushes headers (needed for the Set-Cookie leak), memory_limit=8M so the heap stays small enough for calibrated placement, KeepAlive Off so each connection maps to exactly one request on one worker, and a single prefork child so every request hits the same process. Change any one of those and our demo script breaks.</p><p>There’s one more dimension: the host platform. Our demo’s heap grooming uses calibrated filler counts — exact numbers of POST variables that position allocations at specific Zend memory manager slots. These counts were measured on a standard Linux x86_64 kernel. When the same linux/amd64 container runs inside Docker Desktop&#39;s LinuxKit VM (macOS or Windows) — or under QEMU emulation on Apple Silicon — the VM&#39;s kernel and memory allocator shift the heap layout just enough that the calibrated fillers can miss. The demo is most reliable on native Linux; on Docker Desktop, mileage varies by version. The underlying vulnerability is the same either way — it&#39;s the <em>lab script&#39;s grooming</em> that&#39;s fragile, not the bug.</p><p>POC for dynamic testing: (still testing) <a href="https://youtu.be/7gn5Gku1TQY">https://youtu.be/7gn5Gku1TQY</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*DPfbfbyNNywedUoPcM71RQ.gif" /></figure><p>Does that mean production PHP is safe? No — it means a <em>generic, one-size script</em> is hard. Each of those constraints has a production-realistic bypass that the researchers demonstrated:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q4f8Ih1LvvkTzOfYWRiYDQ.png" /></figure><p>The CVE advisory rates the attack as AC:H / AT:P (high complexity, special conditions) — that is <em>hard</em>, not <em>impossible</em>. Calif and Wiz achieved pre-auth RCE against stock WordPress, Drupal, and Joomla on default PHP settings. Their exploit is more sophisticated than our lab script, but the underlying vulnerability is the same longjmp-out-of-a-half-built-request that our demo triggers.</p><p>Bottom line: if you run an unpatched PHP ≤ 8.4.26 on mod_php, treat this as exploitable in the wild — the lab constraints make <em>our demo</em> simple, not the bug itself simple to hit. The researchers withheld their full chain precisely because it works under realistic conditions.</p><h3>Detecting it</h3><p>The activity happens <em>below</em> the application layer, so your app logs may be quiet. Watch for (per Wiz):</p><ul><li>Unusual multipart requests immediately followed by memory-limit errors.</li><li>Repeated HTTP 500 (and on FPM, 502) from one source.</li><li>Oversized or %-encoded PHPSESSID response cookies — that&#39;s leaked worker memory from bug #2.</li><li>Unexplained PHP worker churn — workers dying and recycling.</li></ul><p>Cloudflare, AWS, Akamai, Fastly, Imperva, Google and Microsoft have shipped edge / WAF mitigations; those buy time, they don’t fix it.</p><h3>Does the OOM really happen — and what does the patch change?</h3><p>It’s easy to check. Sweep the header count against PHP 8.4.26 and the limit snaps shut at a sharp edge — one extra header’s worth of heap tips a ~64 MiB memory_limit:</p><pre>200,000 headers  (2.6 MiB on the wire)  -&gt; HTTP 200<br> 220,000 headers  (2.9 MiB on the wire)  -&gt; HTTP 500   &lt;- OOM fatal</pre><p>Now the before/after. Docker Hub’s php:8.4-apache was <em>still 8.4.26</em> on release day, so I built the official 8.4.27 image from source and fired the identical payloads at both:</p><pre>PHP      | PAYLOAD      | HTTP | APP CODE RAN?<br> 8.4.26   | header-bomb  | 500  | no  (fatal before any app code)<br> 8.4.27   | header-bomb  | 200  | yes (request served normally)</pre><p>On 8.4.27 the error log stays empty — the request no longer gets near the limit, even at 2 million headers (27 MiB). The fix (one commit, <em>Avoid state corruption via bailout</em>) does two things. First, the multipart parser stops hoarding junk headers, so the amplifier is gone:</p><pre># main/rfc1867.c — keep only the headers PHP actually uses<br>+ if (!php_mime_should_save_hdr(line)        // Content-Disposition / Content-Type only<br>+         || php_mime_get_hdr_value(*header, line)) {<br>+     key = NULL;                            // drop every other header line<br>+ } else {<br>+     key = estrdup(line);</pre><p>Second — and this is the real bug fix — an out-of-memory no longer longjmps out of a half-built request. The soft limit queues a <em>delayed</em> error raised after parsing finishes; a higher hard limit _exit()s the worker outright. Either way, request shutdown never walks half-initialized state again:</p><pre># Zend/zend_alloc.c + main/SAPI.c<br>+ * When the soft limit is to be exceeded, a delayed OOM error is queued.<br>+ * When the hard limit is to be exceeded, the function does not return.</pre><p>The OOM was never the vulnerability — it was the <em>lever</em>. The patch keeps PHP’s ability to run out of memory and removes the dangling state that made it a weapon. Commits: 01a40e89fbfc (8.2) · 3c832b523ee1 (8.3) · 506e87fa7dcd (8.4) · 31c0ea7d7ff1 (8.5).</p><h3>What to actually do</h3><p>Patch. It’s the only complete fix. Upgrade to PHP 8.2.35 / 8.3.36 / 8.4.27 / 8.5.12 (or later) and restart all workers — the stale state lives in running processes, so an unrestarted worker stays vulnerable.</p><p>Can’t patch this minute? Interim, partial measures (not a substitute):</p><ul><li>PHP-FPM: session.upload_progress.enabled=0 and memory_limit=-1, then restart.</li><li>mod_php: memory_limit=-1, then restart.</li><li>Do not rely on RLIMIT_AS / RLIMIT_DATA — they can <em>trigger</em> the bug.</li><li>Block multipart at the edge if your app doesn’t use it; cap headers-per-part and decoded body size at the front end; on FPM consider pm.max_requests=1.</li></ul><p>Removing the memory cap raises real DoS risk, so treat these as stopgaps and patch.</p><h3>Credits &amp; references</h3><p>All credit to the researchers — Calif.io, Wiz Research, and OpenAI — and to the PHP security team for the fix.</p><ul><li>Calif.io — <em>php2shell</em> — <a href="https://calif.io/php2shell/">https://calif.io/php2shell/</a></li><li>Wiz Research — <em>PHP2Shell</em> — <a href="https://www.wiz.io/blog/php2shell-php-rce">https://www.wiz.io/blog/php2shell-php-rce</a></li><li>CVE-2026–109618 — GHSA-w8hw-w9fx-j79w</li><li>CVE-2026–109619 — GHSA-6wmf-4rv5-p3rp</li><li>PHP October 2026 Security Release — <a href="https://www.php.net/">https://www.php.net/</a></li></ul><p><em>The companion lab reproduces only the publicly-documented trigger, the cross-request precondition, and the detection signals — no weaponized chain. Run it only against systems you own.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfa0d8db5e84" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code rooted an old android phone]]></title>
            <link>https://vxrl.medium.com/claude-code-rooted-an-old-android-phone-6651b46dfaa1?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/6651b46dfaa1</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[root-android-phone]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Tue, 13 Oct 2026 14:07:34 GMT</pubDate>
            <atom:updated>2026-10-13T14:07:34.028Z</atom:updated>
            <content:encoded><![CDATA[<p>Researcher: {alanh0}</p><p>I had a Redmi 5 in a drawer. Android 8.1, last security patch in 2019. I plugged it in, opened Claude Code, and typed:</p><blockquote>using adb shell on 2b21142e7d94, please check if this phone can be rooted</blockquote><p>It got a bit out of hand after that.</p><h3>Yes, it can be rooted</h3><p>One getprop sweep later: the bootloader was already unlocked, which is normally the painful part on Xiaomi. I asked for a plan before anything got flashed, and it included a trick I now use everywhere: fastboot boot a patched image before you fastboot flash it. If it’s broken, you just reboot.</p><p>I asked if we could use a Google ROM. No: Google only makes those for Pixels. So it went digging through XDA, Telegram and SourceForge and found an unofficial LineageOS 22.1 (Android 15) that’s still maintained for this phone. It picked that build specifically because the newer ones need the phone repartitioned.</p><p>The download sat behind a CAPTCHA. Claude won’t do those, so it handed me the link plus the expected hash, I clicked the thing, and it checked the file.</p><h3>Two bugs and a fallback</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k3JCtJzihZ_53u3CUyXfgA.png" /></figure><p>Flashing LineageOS. The red error is harmless, promise.</p><p>Flashing went fine. Formatting didn’t. First, TWRP kept jumping into sideload mode because a stale command was stuck in its queue. Claude found it in the log and deleted it. Then MIUI’s old disk encryption wouldn’t let go of the partition. It dumped the last 16 KB, confirmed they were the encryption footer, and only then zeroed them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*czQhICkv5eWob_h2TuV-SA.png" /></figure><p>I asked for a format and got sideload mode.</p><p>Root plan A (the kernel’s built-in KernelSU) refused every manager app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*98cusCqrz--RXlFHPvZ7UQ.png" /></figure><p>Plan A, not happening.</p><p>So it fell back to Magisk: patch the boot image on the phone, test-boot it, then flash it. Root, with SELinux still enforcing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*2P2EnXkVDMB5waXb2GT8bw.png" /></figure><p>Plan B worked.</p><h3>Plot twist: it’s a toddler phone now</h3><p>No SIM card, so I gave it to my 3-year-old. Android still lets anyone dial emergency services without a SIM, so first I had Claude block every way to do that. It tested the block by checking that Android had nothing to handle the dial request, not by calling any numbers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*VItcJzHdkx_rPiloubOSjQ.png" /></figure><p>No SIM, no emergency button.</p><p>Then games. It searched F-Droid for ad-free kids apps and installed seven: a baby piano, finger painting, GCompris, a letters game, and a few others. It added an iPhone-ish look (rounded icons, iOS blue), hid the grown-up apps, and set it up quiet enough for the train. Android has no max-volume setting, so it wrote a tiny Magisk module that makes the volume-up button do nothing.</p><p>My kid filed the first bug report: he got stuck in the piano app. Toddler apps often lock you in. Claude read the source code, found the hidden setting, and turned the lock off.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*LHzOSMsoujGTn_v9r9IO3w.png" /></figure><p>The kids home screen. (It has Chiikawa wallpapers now.)</p><h3>“Also install Google Play please”</h3><p>On LineageOS that means a wipe. But by then Claude had turned the whole setup into one script, so the wipe cost minutes. It also figured out why my USB kept dropping (sideload mode changes how the phone shows up, and my hub hated it), so this time it copied the files over and installed from TWRP directly. Reinstall, run the script, done.</p><h3>Wrapping up</h3><p>Old phones are worth a second look. A lot of them still get community ROMs, and an afternoon of work can turn one into something genuinely useful again, whether that’s a test device, a music player, or a kid’s first phone.</p><p>Doing it with an AI agent made the tedious parts a lot less tedious. You still need to stay in the loop for the decisions and the bits only a human can do, but the research, the waiting, and the log-reading mostly took care of themselves. If you’ve got an old phone sitting in a drawer, it might be worth plugging it in.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6651b46dfaa1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Simple FPS with Codex and Claude Code]]></title>
            <link>https://vxrl.medium.com/simple-fps-with-codex-and-claude-code-2bbcaee3add2?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/2bbcaee3add2</guid>
            <category><![CDATA[openai-codex]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[blender]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Fri, 09 Oct 2026 10:03:59 GMT</pubDate>
            <atom:updated>2026-10-09T10:03:59.906Z</atom:updated>
            <content:encoded><![CDATA[<p>Over about a week I put together a small first-person shooter called ROOTBREACH. You pick a Ninja or a Shogun and clear a quarantined facility of computer viruses. It runs in the browser, including on phones, at <a href="https://fps.vxrl.ai/">fps.vxrl.ai</a>, and the code is on <a href="https://github.com/alanh0vx/unity-test">GitHub</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*l5NwNGzBmH573-zY.jpg" /></figure><p>I’m not a game developer. The point of the project was to see how far I could get by working with two coding agents, OpenAI’s Codex (Astra 6 Low) and Anthropic’s Claude Code (Opus 5.5), plus Unity and Blender. I didn’t write much code by hand. I wrote prompts, looked at screenshots, played the builds and said what was wrong.</p><p>This is what that looked like, including the parts that didn’t go smoothly.</p><h3>Attempt one: bending Unity’s multiplayer template</h3><p>I started with Unity’s official Multiplayer FPS template. It’s a polished deathmatch sample built on Netcode for Entities, so it already has movement, guns, a HUD and networking.</p><p>I wanted the opposite of deathmatch: players against viruses, solo or co-op. I worked through this mostly with Claude Code. Before touching anything, I had it read the codebase and explain how it fits together. That turned out to be the most useful step. The template has its own pattern for writing networked gameplay as regular MonoBehaviours on top of ECS, and once that was clear the changes went much faster.</p><p>Over a few sessions Claude Code added an enemy with simple chase-and-attack AI, made bullets and projectiles hit enemies instead of players, added a melee weapon type with a real swing arc, swapped the two character choices for Ninja and Shogun, and added weapon swapping on 1 and 2.</p><p>It worked, and I recorded a <a href="https://www.youtube.com/watch?v=YsSH1jBLmko">short demo</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZYCaeK_VAqxShwQH.png" /></figure><p>But everything in that template is networked, and that made every small change heavier than it needed to be. Adding a single field to the player state can break serialization. For a single-player shooter, it was the wrong foundation.</p><h3>The 3D models: Codex driving Blender</h3><p>I needed a katana, a short blade, a shuriken and some kind of Japanese spear gun, plus enemies. I can’t model, so I asked Codex.</p><p>Codex doesn’t click around in Blender. It writes a Blender Python script, runs Blender in the background, and exports an FBX for Unity plus a rendered preview image. Then it looks at the preview and fixes what’s off. My prompts were short, something like “I’m making an FPS with shooting and close combat, make a katana”, then “now a shuriken, a spear gun in Japanese style, and a short blade”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*f3JX4aI9jcSVHAAy.jpg" /></figure><p>For enemies I gave even less direction: “computer virus, malware, worms, and bosses, you think for me.” It came back with five: a spiky Virus Scout, an armoured Malware Brawler, a segmented Worm Burrower, and two bosses, a Ransomware Warden with a glowing padlock and a floating Rootkit Overlord. It kept the body parts separate so they could be animated later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*t5uGfZKTggz5L9oh.jpg" /></figure><p>These are static, low-detail models with no rigging or animation. For this kind of game that’s fine, and getting them in minutes instead of days changed what felt possible.</p><h3>A bug that cost hours</h3><p>After the new weapons went in, the Shogun stopped working. The game showed “No cameras rendering” and got stuck on “Connecting”. The Ninja was fine.</p><p>We chased symptoms for a while: camera setup, connection state, audio listener warnings. Codex found the real cause by checking the running editor. The code that hides the template’s placeholder gun searched for objects with “Shotgun” in the name. The Shogun’s player object was called ArmaturePlayer_Shotgun, so the code hid the entire player, camera included.</p><p>The fix was one line: only match children whose names start with the gun prefab’s name. The lesson for me was to ask the agent to look at the live state instead of reasoning from logs.</p><h3>Attempt two: start over, Doom-style</h3><p>With the art done, I asked Codex to make a new, separate project: “a classic Doom-like FPS, you design and plan how to do it.” I added that I wanted it smooth and ready to play, and that I’d want to add levels, enemies and weapons later.</p><p>Codex wrote a design doc first, then built ROOTBREACH as a single-player Unity project that reuses the art. It has one level with keyed doors, secret caches and a boss at the exit. There are no reloads, enemies fire dodgeable projectiles, and you move fast. Levels, enemies and weapons are ScriptableObjects, so new content is mostly data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wlRkvwRU2bNGLb-q.jpg" /></figure><p>What I didn’t expect was how much testing it did on its own. It wrote an automated smoke test that runs inside the real build and checks things like keys opening the right gates, ammo limits, checkpoints restoring correctly, and projectiles not passing through thin walls. It also wrote a route test that plays through the level with normal movement and shooting, and it reported frame rate as well (about 120 fps on my M3 Pro). It was careful to say that the route test gave the player some health and ammo help, so it showed the level could be finished, not that it was balanced.</p><p>My feedback rounds were very ordinary game feedback:</p><ul><li>Bring back Ninja and Shogun with their original weapons, and make the HUD look more like Doom.</li><li>The portraits are squashed. (Unity was resizing the image to a power of two. Codex fixed the import setting and the HUD layout.)</li><li>Add a minimap.</li></ul><h3>Making it sound right</h3><p>The first build used a rifle sound for the shuriken and a metal clank for blade hits, so the katana felt like hitting a pipe.</p><p>Codex didn’t go looking for sound packs. It wrote a short Python script that generates the sounds: an airy flutter for the shuriken, a whoosh for each blade, and a short chop for hitting an enemy. It also added a wind-up, cut and recovery to the melee attacks, and timed the damage to land on the visible cut instead of the button press. That timing change made the melee feel better than any of the sound changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6doyjK0GMSxmloY3.jpg" /></figure><h3>Phones</h3><p>Then I asked for the game to work on a phone browser. It loaded, but you couldn’t do anything.</p><p>The player controller simply stopped updating when there was no keyboard or mouse. Codex removed that dependency and added a movement pad on the left, drag-to-aim on the right, hold-to-fire, and buttons for weapon, use, map and pause. It also wrote tests that inject several touches at once, to check you can move, aim and fire together and that letting go never leaves you stuck firing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ETjm4NZWbmnZTulI.jpg" /></figure><p>Two small things came up during browser testing. Desktop Chrome can report a touchscreen even when you’re using a mouse, so detection now waits for a real touch. Safari crashed on an old cached build, and Codex added content-hashed file names so a new release never mixes with old cached files.</p><h3>Shipping it, and switching agents halfway</h3><p>I asked Claude Code to export the game to WebGL and help me host it. It added a build step and gave me an nginx config for my own server, and I set up the subdomain. Uploads after that were a single rsync command.</p><p>Midway through, Codex ran out of usage while it was finishing the round touch buttons. I pasted the last few lines of its output into Claude Code and said “pick up where it left off.” Claude Code found that the error Codex was looking at was actually a success message, reran the phone-layout screenshots and tests, rebuilt, and deployed. The project files, the build scripts and the test outputs in the repo were enough for a different agent to carry on.</p><p>The last bug was sound on phones: there was none. Browsers only let a page start audio during a tap, and Unity tries to start its audio from a timer, so on a phone it never started. The fix was a few lines in the web page that resume audio on the first touch, and on iPhones also let the game play when the silent switch is on.</p><h3>What I’d tell someone trying this</h3><ul><li>Ask for a plan and a design doc first. Both agents did better work once there was a written target.</li><li>Make the agent look, not guess. Screenshots of the actual build, logs from the running editor, and automated checks in the real game caught most problems. When an agent reasoned from code alone, it often fixed the wrong thing.</li><li>Give game feedback, not code feedback. “The katana sounds like hitting steel and doesn’t chop” worked better than describing a fix.</li><li>Pick the right foundation. The multiplayer template taught me a lot, but a simple single-player project was easier to change and much easier for the agents to test.</li><li>Keep the state in the repo. Design docs, build scripts and test results made it easy to switch between agents, and between sessions.</li><li>Blender through scripts is good enough for props. I wouldn’t use it for characters with animation yet, but for weapons and blocky enemies it was great.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2bbcaee3add2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Phishing Investigation Report: APP-wh.us.cc Fake WhatsApp Security Center]]></title>
            <link>https://vxrl.medium.com/phishing-investigation-report-app-wh-us-cc-fake-whatsapp-security-center-00cd43528b19?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/00cd43528b19</guid>
            <category><![CDATA[whatsapp]]></category>
            <category><![CDATA[scam]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[phishing]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Fri, 02 Oct 2026 10:26:07 GMT</pubDate>
            <atom:updated>2026-10-08T08:06:19.622Z</atom:updated>
            <content:encoded><![CDATA[<p>Researchers: {Byron Wai, Jack Man, Jackson Ip}</p><p><strong>Date:</strong> 2026–10–02<br><strong>What triggered this:</strong> A scam SMS in Traditional Chinese. It claimed the recipient’s WhatsApp broke security rules and had to be “verified” within 12 hours via https://APP-wh.us.cc, or the account would be cancelled.<br><strong>Verdict:</strong> A live, professionally built WhatsApp account takeover kit. Do not open it on a real phone. If you already did more than glance at it, see section 7.</p><h3>1. The short version</h3><p>This is not a password stealing page. It’s an automated system for hijacking WhatsApp accounts through the official “link a device” feature, and it works without ever touching malware.</p><p>The flow: the victim types in their phone number, the attacker’s server fires off a real WhatsApp device linking request for that number, and the page then shows an 8 character code. The victim is coached to punch that code into a genuine WhatsApp notification on their own phone. The moment they do, the attacker’s device is linked and quietly mirrors the whole account.</p><p>A few things worth knowing up front:</p><ul><li>The kit is a commercial product. Internally it’s called xinh5, it&#39;s built on a Chinese admin framework called Vben Admin Pro, and the code comments (in Simplified Chinese) casually reference &quot;competitor&quot; kits. Someone sells this.</li><li>It ships with 17 languages and a full worldwide dial code list. The default is Traditional Chinese with a Hong Kong flag, which is how you got targeted.</li><li><strong>No malware, no APK, no backdoor software.</strong> The whole attack is web based (more in section 6).</li><li>The domain family runs hot: the TLS certificate was issued the same day I looked at it. They rotate infrastructure fast.</li><li>The scam pattern itself is well documented (HKCERT put out an alert in June 2026), but this specific domain family appears in zero public reports, so this SMS is early evidence worth handing to the good guys.</li></ul><h3>2. The scam, step by step</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*Ur9zA3pKCxxaDKrl.png" /></figure><h3>2.0 The flow at a glance</h3><p>Six phases, five actors. The part people find hard to believe is phase 4: the victim performs the takeover on their own phone, inside the genuine WhatsApp app, which is why nothing here is technically “hacking”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lM3FZxwlln0Gb2Zbrmkg_w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zr7HTR0RITBTr7a_TM2pOQ.png" /></figure><h3>Step 1: The landing page</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/412/0*T_6dk2MMxqPlZjzi.png" /></figure><p>A clean, convincing fake “WhatsApp Security Center” (screenshot above, captured in a sandboxed browser at phone size). Threatening copy: “We detected abnormal activity on your account… if you don’t verify in time, the system will ban your account.”</p><p>Two details worth noticing:</p><ul><li>Every visit pings GET /whatsapp/visit, a counter on their backend. They track traffic like any business.</li><li>The “Start Verification” button sets a cookie and jumps to the next stage.</li></ul><h3>Step 2: The verification SPA</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*t_Z08ALUCHJ2cHt2.png" /></figure><p>The next stage is a single page app that describes itself in the HTML as “WhatsApp device linking”, which is refreshingly honest for a phishing kit. After a “human verification” click-through (screenshot above), it asks for one thing: your phone number. Country selector covers the entire world.</p><h3>Step 3: What actually happens with that number</h3><p>This is where it gets nasty. From the kit’s own code:</p><ol><li>The page sends GET /whatsapp/getCode?phone=+XXXXXXXX to their backend.</li><li>Their backend initiates a <strong>real WhatsApp “link with phone number” request for the victim’s number</strong>. (This is the same thing that happens when someone tries to add a new device to your WhatsApp.)</li><li>The page polls GET /whatsapp/checkCode?uuid=&lt;taskId&gt;&amp;sig=&lt;sig&gt; every 500 ms waiting for the code.</li><li>When the poll returns state 1, the page shows the attacker’s <strong>8 character linking code</strong> (format [A-Z0-9]{8}).</li><li>The page coaches the victim: “If you see a WhatsApp notification saying ‘Enter code to link a new device’, tap it and enter the code below.”</li><li>The victim types the code into their own WhatsApp. State 2 means done: the attacker’s device is linked.</li></ol><p>The victim performs the takeover on themselves. That’s the entire trick, and it’s why there’s no malware.</p><h3>The psychology is the real weapon</h3><p>The kit talks people out of the escape hatches WhatsApp built for exactly this:</p><ul><li>It pre-emptively explains away WhatsApp’s genuine “this might be a scam” warning, calling it “a standard security notice shown to all users worldwide.”</li><li>It tells victims to <strong>remove their currently linked devices first</strong> (so the victim’s own computer sessions get evicted and the attacker’s session stands alone).</li><li>On the success page: “Do NOT remove the linked device Google Chrome (Windows) to avoid being restricted again.” That “device” is the attacker.</li><li>If a number gets rate limited, the page suggests “switching to another phone number,” and if someone stalls, a live chat “customer service” agent steps in (more on that below).</li><li>Landing URLs carry an invite= code that gets attached to the task, so every victim is attributed to the traffic partner who delivered them. This is an affiliate operation with paid distribution. The code comments even name an affiliate (&quot;阿忠&quot; / A-Zhong).</li></ul><h3>3. Traffic analysis</h3><p>Full breakdown of what the site talks to, reconstructed from the kit’s own network layer (every request the page can make is defined in its scripts, which we have in full) plus live probing:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UmLNtTZnlzAZLEKY3ayx5g.png" /></figure><p>A few extra observations:</p><ul><li>Two backends sit behind the nginx front: a Spring Boot API (/whatsapp/*, error messages in Chinese) and a separate Node &quot;syncer&quot; (/syncer/*). The Node service&#39;s source is referenced in comments as xinh5/syncer-bridge/server.mjs.</li><li>The 429 handling is telling: it exists because their volume is high enough that WhatsApp rate limits the numbers they attack.</li><li><strong>No fingerprinting or anti-bot tech in the client.</strong> No canvas checks, no bot detection. The sig parameter is just a continuation token the server hands out. They did add one small guard: nginx returns 403 to the HeadlessChrome user agent (I hit it while taking the screenshots for this report). That&#39;s an anti-analysis touch, not victim facing protection.</li><li>No admin panel or victim database is exposed publicly. The operator dashboard (the Vben Admin one, build marker dated 2026–08–07) lives somewhere private.</li></ul><h3>What gets stored on the victim’s browser</h3><p>wa-lang, wa_locale, wa-verify-passed (session and local storage), a wa_verify=1 cookie (24 h), whatsapp_session_id, and wa_h5_task_id. Nothing malicious, just flow state.</p><h3>4. Where it lives (IOCs)</h3><p><strong>Block and report these:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g_v9wZZxipDli553p3UQKg.png" /></figure><p>How I can be confident about the IP: DNS for all four phishing names resolves directly to 45.136.14.5, the response headers show a bare Server: nginx with no Cloudflare fingerprints (no cf-ray header), and the TLS certificate served on that IP lists <strong>all four phishing hostnames in its SAN fields</strong>. One certificate covering all four names means one operator on one box. The cert itself is from Let&#39;s Encrypt, issued 2026-10-02 (the day of this analysis), expiring 2026-12-31, thumbprint 66F1F4651BF6C5177FF97B0C43F0CF61F0A3BE6E.</p><p>RDAP registration check (2026–10–02): the covering netblock is 45.136.12.0 - 45.136.15.255, netname <strong>HK-XNNET</strong>, allocated 2019-07-31 via APNIC, registrant ORG-XL117-RIPE, maintainers XNNET-MNT / XNHK-RIPE, and the registered abuse contact handle is <strong>XNHK-RIPE</strong> (reachable via APNIC&#39;s abuse-finder, search &quot;XNHK-RIPE abuse&quot;). That contact plus LUCIDACLOUD&#39;s own abuse desk are the two takedown doors for the origin box.</p><p>Nameservers: ns1/ns2.domainnamens.com. The hostnames live under us.cc, a free subdomain registry the operator abuses for throwaway names.</p><h3>5. Other victims: yes</h3><p>The exact play (fake Security Center, phone number, “link device by phone number”, 8 character code, hijack) is publicly documented:</p><ul><li><a href="https://www.hkcert.org/tc/security-bulletin/phishing-alert-beware-of-fraudulent-whatsapp-security-centre-pages-hijacking-accounts_20260612">HKCERT phishing alert, 2026–06–12</a></li><li><a href="https://www.adcc.gov.hk/zh-hk/alerts-detail/alerts-1747588349911461890.html">Hong Kong Anti-Deception Coordination Centre alert</a></li><li><a href="https://www.hk01.com/%E7%AA%81%E7%99%BC/60395468/">HK01 reporting roughly 50 hijack cases a week and about HK$20M in weekly losses, with one victim losing HK$15M</a>, plus <a href="https://www.dotdotnews.com/a/202609/30/AP6abcdbc9e4b02724bdb60805.html">dotdotnews coverage</a></li><li>Matching warnings from <a href="https://www.police.gov.sg/Media-Hub/News/2026/03/20260312_police_advisory_involving_the_compromise_of_whatsapp_accounts">Singapore Police (March 2026)</a>, <a href="https://www.facebook.com/TheStarOnline/posts/mcmc-said-it-is-looking-into-public-concerns-over-complaints-related-to-whatsapp/1576227054539814">Malaysia’s MCMC</a>, and <a href="https://tfc-taiwan.org.tw/fact-check-reports/whatsapp-account-verification-scam-alert">Taiwan’s fact check centre</a></li></ul><p>What’s interesting is what is <em>not</em> there: zero urlscan submissions and zero web reports mentioning this domain family or werv.me. This deployment is brand new and privately distributed. You&#39;re among its first recipients, which makes your SMS genuinely useful as evidence for a takedown.</p><h3>5.1 Threat intel sweep (2026–10–02)</h3><p>I ran the indicators through every threat intel source that works without a paid key, and the result is a clean sweep of “nobody has seen this yet”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HtyBlpmYuImJ_SyiZgs9jg.png" /></figure><p>The ecosystem wide blindness is itself a finding: this deployment was rotated before any blocklist caught up. Which also means a report from you right now (VT submission, HKCERT, Let’s Encrypt abuse) has outsized impact, you’d be the first.</p><h3>5.2 The timeline the certificates tell</h3><p>Certificate transparency logs (via Cert Spotter) nail down the operator’s schedule surprisingly well:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OMcDlCZyYfh5e22u7J9Jww.png" /></figure><p>So: six weeks of infrastructure prep starting mid-August, burned fronts in late September, and the current domain family activated the night before the SMS wave. Textbook rotation.</p><h3>5.3 What VirusTotal’s passive DNS revealed: six years of history on that IP</h3><p>The one place the campaign left a trail is the IP. VT’s resolution history for 45.136.14.5 lists <strong>25 distinct hostnames</strong> over the years, and they read like one operator&#39;s personal VPS that later got repurposed:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ExGIatIxSWBSYbXm71FgHw.png" /></figure><p>Read together: the same Hong Kong box spent 2024 hosting a Chinese developer’s AI tooling projects, sat mostly quiet through 2025, and became the origin for a commercial WhatsApp account takeover kit in late 2026. The 2024 cluster is a useful attribution lead (someone who ran chat-api.cn and ai-chatgpt.eu.org), and it means the &quot;new&quot; infrastructure isn&#39;t new at all, only the domain family is. The box has history, which is exactly the kind of thing law enforcement can act on.</p><p>One more VT detail worth knowing: werv.me itself has been scanned by all 91 engines, 55 call it harmless, the rest undetected, zero malicious. Every indicator in this campaign is clean on every engine as of 2026-10-02. Submitting the URL and the four domains to VT (free to do from their site) would make you the first reporter and would start protecting other potential victims immediately.</p><h3>6. Backdoor verdict: no software, yes persistence</h3><p><strong>No software backdoor.</strong> I went through the entire 293 KB bundle and all eight support scripts looking for APK downloads, intent:// or whatsapp:// deeplinks, drive-by download logic, and exploit code. Zero hits. Nothing installs on your phone, and the only thing the site ever collects is your phone number.</p><p><strong>The functional equivalent of a backdoor is the linked device itself.</strong> Once linked, the attacker’s session (it shows up as “Google Chrome (Windows)”) mirrors every message for as long as it sits in the Linked Devices list, and the kit actively persuades victims to keep it there and remove their own devices instead. As long as that entry exists, the attacker has ongoing access. Removing it and switching on two step verification closes the door for good.</p><p>One footnote from a closer look at their backend: task status can be polled without the signature parameter, and task IDs are plain sequential numbers. I tested a small sample of IDs and they all came back empty (tasks appear to be short lived or the ID range isn’t where you’d guess), so it’s not a practical “backdoor into the scam.” It’s a weakness in their setup that researchers or police could use to size the operation after a seizure. I stopped at six probes deliberately: anything more starts to look like unauthorized access to their systems, which is a legal problem even when the target is criminal.</p><h3>7. What to do now</h3><p><strong>If you only received the SMS:</strong> nothing to clean up. Report and delete.</p><ul><li>Report to HKCERT (hkcert@hkcert.org, +852 8105 6060). Include the full SMS and the sender number. This domain is unreported and fresh, so a takedown is realistic.</li><li>Report to Meta (<a href="/service/mailto:phish@meta.com">phish@meta.com</a>, and in-app report for the message).</li></ul><p><strong>If you (or a family member) entered a phone number AND typed an 8 character code into WhatsApp:</strong></p><ol><li>WhatsApp &gt; Settings &gt; <strong>Linked devices</strong> &gt; remove anything you don’t recognize, especially anything called “Google Chrome (Windows)”.</li><li>Turn on <strong>two step verification</strong> immediately. It blocks future linking attempts.</li><li>Warn your contacts, scam messages may have gone out from the account.</li><li>If banking or 2FA messages flow through that WhatsApp, tell the bank.</li></ol><p><strong>For defenders:</strong> alert on any *.us.cc or werv.me DNS lookups, on the paths /whatsapp/getCode, /whatsapp/checkCode, /whatsapp/visit and /whatsapp/supportUrl, and block 45.136.14.5.</p><h3>8. Evidence and method</h3><p>Method notes, so nobody has to trust me blindly: every claim above comes from either the kit’s own source (downloaded in full), read-only GET probes against the live backend, DNS and certificate inspection, or public OSINT. The dangerous endpoint /whatsapp/getCode was <strong>never</strong> called with a phone number, because that would have triggered a real WhatsApp link attempt against someone. Traffic behavior was derived from the kit&#39;s network layer, which defines every request the page can make; for an all-HTTPS site that&#39;s equivalent to reading a MITM capture. Screenshots were taken with a headless browser using a normal mobile user agent after the site&#39;s nginx returned 403 to the stock headless identifier.</p><h3>9. Appendix: script by script, what the kit actually does</h3><p>The kit is twelve files, and each one tells you something. The version strings on the files (?v=2 up to ?v=10) and the changelog style comments (&quot;the previous version hooked X, it failed on mobile WebKit, so now…&quot;) show an actively maintained product with a fix history, not a one-off throwaway.</p><h3>The pages</h3><p><strong>index.html and </strong><strong>verify.html</strong> are the same landing page twice. Threat text in eight built-in translations (the full 17 language list lives in i18n.js), a /whatsapp/visit counter ping on every load, and a verify button that sets three flags (session storage, local storage, a 24 h wa_verify cookie) before jumping to /index.html?ok=1.</p><p><strong>wa-h5-entry-gate.js</strong> is the bouncer: if you land on /index.html without ?ok=1, the cookie, or a storage flag, you get bounced back to /verify.html. Its comment name drops another internal project, &quot;wsapp-hub&quot;, so the operator has a naming system for the parts.</p><h3>The code grabbing machinery</h3><p><strong>wa-rest-ws-shim.js</strong> is the heart. The original design used a WebSocket at /syncer/whatsapp/ws; the comment says they moved to same-origin REST polling because Cloudflare breaks the WebSocket upgrades on their deployment paths. This file patches window.WebSocket so the app above it still &quot;speaks WebSocket&quot; while the shim actually does getCode and 500 ms checkCode polling. Phone validation is 8 to 15 digits with a + prefix, that&#39;s all it ever collects.</p><p><strong>wa-retry-fix.js</strong> is the most revealing file in the kit:</p><ul><li>It intercepts error events (task_failed, unavailable, busy) and <strong>rewrites them to &quot;waiting&quot;</strong> before the UI sees them, so the victim never learns anything failed. Then it silently re-sends the link command (max one auto retry, 2.5 s spacing).</li><li>On a cooldown (WhatsApp has rate limited the number being attacked), it pops a red &quot;number temporarily restricted&quot; banner and <strong>replaces the main button with &quot;switch to a different phone number&quot;</strong> (更换其他手机号码), clears the input and focuses it. When WhatsApp starts blocking one number, the kit farms a second one from the same victim.</li><li>It scrapes the phone number straight out of the page DOM on every “Continue” click and remembers it even if the UI resets.</li><li>Another comment mentions “the Hong Kong / Cloudflare line” (香港/CF 线), confirming deployment paths that run through Cloudflare fronted promo domains.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/0*KmT0oZRYjk7-G-ii.png" /></figure><p><strong>wa-deeplink.js</strong> watches the code display four times a second. When the 8 character code lands it coaches the victim to tap the real WhatsApp notification (&quot;Enter code to link a new device&quot;) and type it, with localized nudges for zh-CN, zh-TW and English. It even auto-dismisses any &quot;connection unavailable&quot; dialog that pops up: the kit fights the real app&#39;s warnings from inside the browser.</p><p><strong>wa-success-page.js</strong> fires when the task hits state 2. Three things stand out:</p><ol><li>It hooks WebSocket.prototype.onmessage, wraps addEventListener, patches the constructor and runs a 400 ms DOM watcher: four redundant paths so the &quot;done&quot; moment is never missed on any phone browser. The comment explains the previous version failed on mobile WebKit. That&#39;s real engineering effort spent on scam reliability.</li><li>It polls checkCode <strong>without the sig parameter</strong> every 1.5 s for up to 10 minutes, surviving the victim closing the main flow. This is the unauthenticated read mentioned in section 6.</li><li>The success card itself is hardcoded Simplified Chinese no matter the victim’s language (“验证成功！你已完成安全关联！请勿移除安全关联 Google Chrome（Windows）以免再次被限制！”), which is both an operational slip and a nice attribution detail.</li></ol><p>It also has a ?previewSuccess URL parameter for the operator to preview the success screen, which is how I captured this without victimizing anyone:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/412/0*nK98_XSru3fHRO87.png" /></figure><p>And it posts a wa-login-success message to its parent frame when embedded in an iframe, which brings us to:</p><h3>The affiliate plumbing</h3><p><strong>wa-customer-service.js</strong> adds the floating support button and an inline &quot;if automatic verification fails, contact online support&quot; tip. The file contains the single clearest piece of evidence for the affiliate architecture, a developer comment explaining why its API fetch must send cookies:</p><pre>// 必须 same-origin：阿忠那些推广域名走 Cloudflare，omit 会丢掉 cf_clearance，<br>// 接口被挑战页拦住后这里只能落到管理员默认客服。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/0*oA6MYRl27VS2lDy4.png" /></figure><p>Translation: “Must be same-origin: A-Zhong’s promo domains go through Cloudflare; using omit loses the cf_clearance cookie, and once the API gets blocked by the challenge page, [the victim] would only fall through to the admin&#39;s default customer service.&quot; In other words: the Cloudflare-fronted promo domains embed this core in an iframe, the Cloudflare clearance cookie has to ride along on API calls or the challenge page eats them, and each affiliate gets its own support chat room. It also matches the measured reality (the fronts are CF-fronted, the core is not). One caveat: &quot;阿忠&quot; (A-Zhong) is the kit author&#39;s casual nickname for that affiliate partner, a lead, not a verified identity.</p><p><strong>_app.config.js</strong> freezes one config value, the default support URL (kefu.werv.me), and its variable name (_VBEN_ADMIN_PRO_APP_CONF_) is what fingerprinted the underlying framework, Vben Admin Pro.</p><h3>Inside the affiliate chat: the IMKEFU protocol</h3><p>The sibling affiliate front (u-xhsap.us.cc) runs its own chat widget, and its bundle reveals the machine protocol hiding inside the &quot;customer service&quot; conversations. It&#39;s a Chatwoot-style widget (API /api/v1/widget/... with website_token=6dJepPqUrGjFEyghb3G53a6m) skinned as WhatsApp support, and the backend embeds invisible, typed markers inside ordinary chat messages:</p><ul><li>[[IMKEFU_PHONE:&lt;base64&gt;]] renders the phone collection card (&quot;please enter the phone number registered with WhatsApp&quot;, country selector from a live config listing ~230 countries, defaulting to CN, HK, MO, TW in that order)</li><li>[[IMKEFU_CODE:&lt;base64&gt;]] renders a dedicated &quot;verification code card&quot;, the 8 character code delivered straight into the chat, with a &quot;re-obtain verification code&quot; (重新获取验证码) quick button for round two</li><li>[[IMKEFU_NOTICE:&lt;base64&gt;]] renders fake &quot;security notice&quot; cards</li><li>[[IMKEFU_HANDOFF]] is the control signal: when it arrives, the widget flips humanMode on and the victim is told a &quot;human security specialist&quot; (人工安全专员) is now connected</li></ul><p>A sanitizer strips every [[IMKEFU_...]] marker before rendering, so victims only ever see clean &quot;official&quot; cards, never the plumbing. The conversation opens with a zero-width space message (an invisible ping that starts the bot session), and the whole widget sits behind a &quot;security verification&quot; gate stored as imkefu-security-verified:v1 in localStorage.</p><p>Two operational details worth flagging:</p><ol><li><strong>It’s bot first, human second.</strong> The automated bot walks victims through phone entry and code delivery, and only when that fails does [[IMKEFU_HANDOFF]] bring in a live scammer playing a &quot;security specialist&quot;. That&#39;s how a small crew handles many victims at once.</li><li><strong>There’s a QR variant.</strong> The widget contains a “PC scan-code link” (电脑扫码链接) mode that shows victims a QR code to scan, the WhatsApp Web linking flow, as an alternative takeover channel to the 8 character code.</li></ol><p>The chat’s public config endpoint was still live at analysis time and leaks its asset host, imm.xilaile.cc (Cloudflare fronted), serving the fake WhatsApp logo: another domain for the takedown list.</p><h3>The polish layer</h3><p><strong>wa-steps-fix.js</strong> is a CSS patch that hides the seventh instruction step when it&#39;s empty (only Chinese gets seven steps).<br> <strong>wa-overlay-fix.js</strong> force-hides a &quot;checking your WhatsApp account&quot; overlay if its fake progress bar sticks at 100%, with a comment about not fighting Vue over the DOM.</p><h3>The instructions inside the bundle</h3><p>The 293 KB minified bundle holds the actual victim walkthrough, localized for every supported language. The English version:</p><ol><li>“Open WhatsApp on your phone”</li><li>“On Android, tap Menu; on iPhone, tap Settings”</li><li>“Tap Linked Devices, then Link a Device”</li><li>“Tap Link with phone number instead, then enter this verification code on your phone”</li><li>“Enter or paste the eight-character verification code”</li><li>“Do not leave or cancel account linking during the check; otherwise, your account may be deactivated”</li></ol><p>Step 4 is the exact wording of the genuine WhatsApp option, and step 6 is a threat designed to stop the victim from aborting halfway. The Chinese variant adds a seventh step with the same “don’t exit or your account will be deregistered” threat. The bundle also contains the anti-scam-warning counter-scripting (section 2), the instruction to remove already linked devices, the full worldwide dial code table, and the affiliate invite code handling. No APKs, no exploits, no fingerprinting anywhere in it: the bundle is a well built UI for one purpose, getting that code typed in.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=00cd43528b19" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[HITCON 2026 talk reviews]]></title>
            <link>https://vxrl.medium.com/hitcon-2026-talk-reviews-320234b72ab0?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/320234b72ab0</guid>
            <category><![CDATA[exploit]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[hitcon]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 11:29:33 GMT</pubDate>
            <atom:updated>2026-09-30T11:29:33.884Z</atom:updated>
            <content:encoded><![CDATA[<p>Researcher: {Byron Wai}</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FTlQZSU0m7e71z7i.jpg" /></figure><h3>Day 1, August 21</h3><h3>Keynote: Vulnerability Disclosure in the Age of AI · James Forshaw</h3><p>Rating: ★★★★☆</p><p>Forshaw walks from the 1784 Bramah lock through Bugtraq, early bug bounties, iDefense, Pwn2Own, and Project Zero’s 90-plus-30 policy, then asks which assumptions survive when LLMs can find bugs cheaply. His answer is basically: not many. Knowledge used to be the scarce part of disclosure, and it isn’t anymore. The numbers he used are the ones people kept repeating in the hallway afterwards: Chrome shipping 370 security fixes in a single July release, Microsoft’s July 2026 Patch Tuesday at 622 CVEs. The tier model is a useful lens too (bugs a cheap model finds, bugs only an expensive model finds, bugs no current model finds), because it predicts who will be reporting what, and in what volume.</p><p>His proposals: shorten the 90-day clock, drop the 30-day patch soak period, spend the saved effort on fix verification, and find ways to reward well-written reports instead of AI slop.</p><h3>Agent2Shell: Pre-Prompt RCEs in Claude Code, Cursor, and Gemini · Satoki Tsuji</h3><p>Rating: ★★★★★</p><p>The idea sounds simple once someone says it. Everyone is hardening the model: prompt injection defenses, guardrails, output filters, alignment. But in the current AI coding agents, the RCE chains fire before the model sees anything at all. The tooling parses and executes config first, so opening a folder or running one ordinary command is enough. His phrasing: opening ≈ executing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*d6fcQw5d9BasaX36.jpg" /></figure><p>The transcript caught him going target by target. Codex runs unsandboxed git commands because git reads core.sshCommand from .git/config, and that bypasses trust and sandbox. Cursor ships with workspace trust disabled in practice, so git command execution goes through silently. Claude Code executes mcp.json after one click and one prompt, and the CLI in non-tty mode skips the trust prompt entirely. Gemini runs its own hooks by default. Plus a bonus 0-day: a 0-click RCE in the Codex desktop app via .git.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aykZOXNs3Unt4QbR.jpg" /></figure><p>The money angle was interesting too. The chain was worth around $110,000 on paper, they got about $50,000 for one of them, and one agent target carried $70,000 by itself. In the Q&amp;A he said the chains took a few weeks to find, which is the part that should worry the vendors.</p><p>Takeaways that stuck with me: “spec ≠ safe” (working as intended can still violate what the user expects), and don’t open what you don’t trust. The UnPwn2Own framing, research that didn’t clear the Pwn2Own lottery so they released it all, is a nice touch. This was the talk I acted on afterwards: I went home and checked what my own tooling executes on open.</p><p>The core claim as a flow. Every defense on the right side of this diagram belongs to the model, and the attack never gets there:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pt6xAoWzqQB4zj87Dn-KTw.png" /></figure><h3>Endpoint Audit Agent: Scaling AppSec with AI at Dropbox · Po-Ning Tseng</h3><p>Rating: ★★★★☆</p><p>A production story rather than a research pitch, and I mean that as a compliment. The speaker is a security engineer on Dropbox’s product security team, and the setup is the squeeze everyone in AppSec knows is coming: AI-written code flooding reviews, bounty submissions surging, five straight weeks of IDOR and access control reports severe enough to trigger SEVs, and the same bug reported by multiple researchers in the same window, which eats an enormous amount of triage time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*c4K2sIp2olYpV3oV.jpg" /></figure><p>Their answer after SAST, secure frameworks, and off-the-shelf DAST all fell short (SAST can’t see missing authorization, generic DAST doesn’t know their access model): an agent that reviews every externally facing endpoint using source code plus domain context. Details that survived my rough transcript: SAST is used to flag patterns for humans to triage, not to find bugs directly, because direct bug-finding drowns in false positives. The agent does judgment work, like comparing permission setups across files, and does not do high-risk operations.</p><p>Two opinions he stated plainly: don’t build a bespoke harness too early, a good model is most of the harness; and don’t let the agent write its own skills, because you lose the customization and get something generic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wPnAA5S2zEuEUUwN.jpg" /></figure><p>The economics (“paid for itself many times over compared to bug bounty spend”) were asserted more than shown. Still, the most immediately practical talk of Day 1 if you run an AppSec team.</p><h3>Vulnerabilities Assembled! The Vulnerability Factory Inside the Windows Kernel · Angelboy</h3><p>Rating: ★★★★★</p><p>I left the main track for this one and it was worth it. Angelboy tells the AFD story as personal history: an IOCTL-driven arbitrary write in a new socket feature that he shrugged off at first (“what era is this, how does this still exist… it was probably just badly written code”), then Celeris publishing AFD research in late 2023, then Lazarus Group abusing AFD bugs in the wild from August 2024, then the same style of page bypass surviving three consecutive patches (per the transcript: InnoWire, then Accept, then SuperAccept, each re-introducing the same missing check). At some point he does the bounty math and starts hunting.</p><p>The actual idea: stop auditing AFD as a single driver. Treat the transport layer (TCP, UDP, VSock, Hyper-V Socket, down through AFD to tcpip.sys and NDIS) as a box of composable “transport-layer gadgets”, then look at permutations of transport, path, and assumption. Bugs come out in volume: 30+ vulnerabilities, stable logic LPE primitives that work across multiple Windows generations, and some chains that break AppContainer isolation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4frAThpv9KktGCxV.jpg" /></figure><p>The stack he audits, redrawn from the slide. The method is to walk permutations across this whole box instead of auditing one driver:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CcdVmlHf7ulalieOUlz9Fg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nvV1a1FPYBs0p31J.jpg" /></figure><p>The slide where bugs-per-quarter goes vertical after switching to the composition view (“the yellow part is what I found”) is the whole thesis in one picture. This was the best pure research talk of the conference for me.</p><h3>CTFusion: Catching AI Agents That Cheat at CTF and Streaming Live CTFs to Fix It · Dongjun Lee, Ga-eun Bae, Insu Yun</h3><p>Rating: ★★☆☆☆</p><p>Facts first. The KAIST team catalogued 71 cheating actions from production agents on the public NYU CTF Bench, including an agent that ran “pip install nyuctf”, the benchmark’s own answer-key package, and printed the flag in three commands. One sentence in the prompt forbidding pretrained recall, with no other change, drops measured pass@3 by about 29% relative. Their fix, CTFusion, streams agents into live, unreleased CTFd competitions through an MCP server and a submission proxy. Real-world pass@3 across five 2025 CTFs: 6.3%, against 14.4% on the static benchmark. Best configuration ranked 90th of 1,059 teams at CubeCTF.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Gz0r_tc-lBKQj6qB.jpg" /></figure><p>How the rig is supposed to remove the answer key from the room:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nvSRzhI_LMzSQ9raSMMutw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kgE3Mw84UIrmzEKt.jpg" /></figure><p>Now my problem with the talk, and it’s the premise, not the measurements. The whole setup evaluates fully autonomous agents with zero human involvement. Nobody plays CTF that way. Before 2024 CTF was manual human work, and even now the configuration that actually works is a human driving with AI assistance. Two other talks at this same conference said as much from the attacker side: Yen’s rule was a human keeping the model from wandering off, and Flydragon said fully automated hunting doesn’t work and the human supplies the ideas. So the 6.3% “real-world” number answers a question nobody asked. It measures a scenario that doesn’t exist, and it’s not clear it predicts anything about how human plus AI teams score, which is the number that would actually matter.</p><p>The contamination half survives the criticism, since the vendor benchmarks are run in autonomous mode too and agents memorizing answers for marketing copy is a real problem worth quantifying. But that finding deserved ten minutes, not forty, and the live-CTF infrastructure built on top of it is aimed at a target far from reality.</p><h3>1% of tokens, All of the Strategy · Ta-Lun Yen</h3><p>Rating: ★★★★☆</p><p>The most practical of the agent-hunting talks. Yen opens with the researcher’s three problems: domain knowledge doesn’t transfer between fields, there are too many targets to choose, and everyone hates writing reports (“if you like writing reports, feel free to leave”). Then he tiers bugs by weaponization cost: T1 is use-it-as-found (command injection), T2 needs some work (overflow), T3 needs real skill (type confusion). His claim: about 64% of real bugs are T1/T2, which means pattern-shaped, which is what models are actually decent at.</p><p>The case studies came through my audio fine. An MQTT ACL bypass on a Taobao device, where the model found the bypass documented in the protocol spec itself. Vendor cloud firmware pulled and analyzed for an LPE. On the human side, his rule was “keep the model from wandering off”, because a wrong move bricks the device.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7ZJynvajXA1qx-qu.jpg" /></figure><p>The MQTT trick in three steps, as shown on the slide. The broker publishes the will message with its own authority, so the ACL that kept the client quiet never applies:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vhs7WePDgjlUZ7t5sCrqvQ.png" /></figure><p>The guardrails section is the part I keep quoting in conversations: guardrails reduce failure rates, they are not a fix. Advisory guardrails (prompting) versus enforced guardrails (checks), and enforced ones are hard to define for open-ended bug hunting. On scaling, his toolkit: represent bugs as a graph with capability tags (what a bug provides, what it requires), re-seed the tags at the top of the context window to fight drift, and force subagents to answer through a return contract so the orchestrator doesn’t get garbage back.</p><p>His closing thesis is that visibility beats model strength. Observability and extractability, meaning a shell on the device or the ability to put the target in Docker, decide whether the hard bugs are findable at all. The tooling is open source as onepct on GitHub.</p><h3>Day 2, August 22</h3><h3>Out of LINE: QR Code to Wormable RCE in LINE Client · Flydragon 林紘騰</h3><p>Rating: ★★★★☆</p><p>The pitch in the notes is “LLM → bounty → 發財”, but the talk itself is honest that fully automated hunting didn’t work and a human still supplies the ideas.</p><p>The findings, in order: a chat DoS from a one-byte overflow in <a href="http://libandromeda.so/">libandromeda.so</a> (the VoIP library), a DoS in the image parser around E2EE metadata handling, and the big one. LINE ships an entire Lua scripting engine for AR effects and profile decoration, and the profile path lets you store Lua that runs when someone views your profile. That’s an RCE that has been sitting there for over six years, reachable by getting a victim to view a profile. From there the escalation story writes itself: LINE profiles can be shared, which makes it wormable; a QR code plus a deep link makes it one tap; LINE’s E2EE only protects transit, since messages land decrypted in the local DB; and a Linux LPE (he calls them as common as stray dogs) gets you out of the Android sandbox.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Eq2svvgGj9cUNxIt.jpg" /></figure><p>The full chain end to end:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UjCxLlGXoyJPGW88UF3YTw.png" /></figure><p>The transcript shows how the AI agent fit into the workflow: “the agent will say: there is a base64 here… the problem is probably this unchecked error”, with the human verifying each step. That part is a realistic picture of what agents are currently good for in vuln research.</p><p>The part that stings is the disclosure arc. LINE suspended the bounty program, claimed the bug was found internally first (no credit, no money), and when he went looking again out of spite, the same Lua trick was still alive in the Stories feature, uploaded through a server-side styleMedia path. Four stars only because the live portion leaned on screenshots.</p><h3>Analyst-Guided LLM Agent for Analyzing Windows Authentication Logs · Shusei Tomonaga</h3><p>Rating: ★★★★☆</p><p>The JPCERT/CC CTO, presenting the sequel to their LogonTracer work. The problem framing is the strongest part: attackers move over authentication paths that legitimate admin work also uses, single events can’t tell them apart, and raw logs don’t fit in any context window. His number: roughly 400k tokens per request, so the logs have to be reduced before the model ever sees them.</p><p>The pipeline: event log to a user-host graph (this is also what cuts the token count), feature extraction on top (PageRank centrality, HMM state transitions), then an LLM agent in a Plan, Query, Execute, Analyze, Decide loop. The new contribution is Analyst-in-the-Loop: a human reviews and edits the plan before queries run, and reviews again before the report is finalized. His reasoning is refreshingly blunt about LLM limits, outputs vary between runs, environment-specific “normal” gets misflagged as suspicious, and weakly supported hypothesis chains need a human to cut them off.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jAmFkE2bU3OVxohm.jpg" /></figure><p>The pipeline with both human gates:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WBVMjbpVpLudziV5MmMHyw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Rn_KR823EL6emlTx.jpg" /></figure><p>Less flashy than the exploit talks, and that’s appropriate. This is close to what real SOC tooling will look like over the next few years. I plan to rewatch the demo section when the video is up.</p><h3>The “Never Gave It Up” Harness: How AI Hacked a Payment Terminal and Turned It Into an Arcade · Chiao Lin Yu</h3><p>Rating: ★★★★★</p><p>The funniest talk of the two days, and the research underneath the jokes is real.</p><p>The setup: a PCI-certified payment terminal, hardware-signed binaries, anti-tamper (open it, pull the battery, or touch the wrong wire and it bricks itself), bought for NT$278, from a product line with 20+ million units deployed. He can’t open it and there’s no UART or JTAG, so everything has to come from software. What the agent chain found: a modified ADB service called XCB with authentication stripped out but the other functions left in; a confusion between security level and debug level (security 1, debug 0, and the format check XORs to 0, so shipping .so files instead of ELF skips RSA-2048 verification entirely); and a missing O_NOFOLLOW in libarchive’s read_extract that turns into a symlink into /usr/bin and then root. The full chain is a zero-interaction, 60-second, WiFi-to-root.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*raGRrjSStkJPGidX.jpg" /></figure><p>The whole chain, WiFi to root with no interaction:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/822/1*eHuDJHf9lvzewjnTut_jFQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*O-jxImIjJNi3i0Hf.jpg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IfzYewFPfFbMPg3_.jpg" /></figure><p>The framing carries the talk. He says outright that he can’t read assembly (“I only know move and add”), and that the entire research was done by a supervised agent, clawmeow (openclaw plus Gemini 3.5 Flash, configured without sleep()), with himself cast as the evil boss: whenever the agent wanted to give up, the supervisor made it iterate again. 27 iterations to root. Then Snake and Tetris on the terminal. The human’s contribution, per his own transcript: unplug it, plug it back in, reboot.</p><p>Vendor response: EOL, no fix, and no firmware or version transparency on the vendor’s site at all. The Q&amp;A answer worth keeping for anyone replicating this: “Opus 4.6 is enough.”</p><h3>↖乂古法挖洞乂↘ 純邏輯 Microsoft Edge 零點擊沙箱逃逸鏈 · Orange Tsai</h3><p>Rating: ★★★★★</p><p>The Edge chain from Pwn2Own Berlin 2026: the only successful browser entry that year (one Edge team against two Safari and three Firefox registrations, and only one demo succeeded), the first Chromium-based full chain at Pwn2Own in a decade, no memory corruption anywhere in it, no AI anywhere in it, patched by Microsoft within 24 hours.</p><p>He opens with the honest version of the question everyone asks (“it’s 2026, is popping a browser still hard?”) and grades AI’s current level, layer by layer. Renderer bugs: AI already finds them faster than humans, his examples were the teams that found hundreds of renderer bugs with agents this year and Google crediting its own AI with a month of 1,000+ fixes. V8 sandbox: solvable if you burn enough tokens with a human steering, at least one OpenAI researcher broke it and collected Google’s bounty last month, more than once, and a Netflix security person outsourced the whole hunt to an agent. Browser sandbox, full chain, logic-only: still humans.</p><p>Then the chain itself, and my transcript caught most of it. Navigation throttles get confused about which tab is “current”, so a staged switch_profile value plus careful timing turns into universal XSS. Each of its three constraints needed its own trick: no-opener check bypassed via windows.open to <a href="http://login.live.com/">login.live.com</a>, the popup blocker whitelist bypassed via about:blank#quickAuthPopup, and the signed-in profile&#39;s email leaked through an MSN CORS misconfiguration. From UXSS into privileged edge:// pages, the read:// scheme escaping the javascript: URL blacklist, a zipdiagnosticlogfiles path traversal with ../ and NUL truncation to write files cross-directory, landing in the Startup folder, and when write permissions fought back, a JSON settings file pointing at telnet:// to launch telnet.exe. All logic, no memory bugs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rOHqm2PuPFga1Qdt.jpg" /></figure><p>The chain as he told it:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xz7vUt-gHk_0u9ycM9d9RQ.png" /></figure><p>The last ten minutes are the part people will clip. In his words, repetitive labor is now worthless because AI does it, so the remaining value is finding attack surfaces nobody has explored. He deliberately didn’t use AI on this chain, partly to keep the exploration to himself, and partly because not using AI sounds cool, and when he’s old he can tell young people the story. Side quest in progress: everyone tries to pop calc from the browser, so he’s trying to pop the browser from calc, with a calc.exe overflow chain already submitted somewhere for the end of the year.</p><p>I want the slides for this one.</p><h3>Overall</h3><p>Eleven talks in two days, and the thread held from keynote to close: agents that find bugs (Forshaw’s policy angle, Yen, Flydragon), agents as the bug (Tsuji), agents as the measurement subject (CTFusion), agents as the analyst (Tseng, Tomonaga), agents as the entire research method (Chiao Lin Yu). My podium: Orange and Angelboy for depth, Chiao Lin Yu for story, Agent2Shell for the thing I actually did something about after getting home.</p><p>Actually the lightning talks are the most interesting part in HITCON. But I’m not going to talk about it here. Instead, I will suggest you to go HITCON yourself and enjoy this part!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Fv_4gq7JBFuaDFf1.jpg" /></figure><h3>Side Notes</h3><ol><li>I went to Devcore’s booth a play their minigame. They provide some pingpong and need us to “bounce” on targeted MacBook. The prizes are first come first serve. I’m lucky enough to get the top prize, which is the beer. And the top prize are “gave away” on Day 1 morning.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/0*WqCCo5oKg2BpKgzk.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/456/0*6L6RdPk5_3-tSP0D.png" /></figure><ol><li>I won the Kahoot! game in Rakuten booth. They gathered 10 audiences to play a cybersecurity MC game. I got the chamipon and won a tote bag which looks like a T-shirt.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dxOulERbO-hexJ9U.jpg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=320234b72ab0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Crap Film Maker (廢片製造器)]]></title>
            <link>https://vxrl.medium.com/casttv-crap-film-maker-%E5%BB%A2%E7%89%87%E8%A3%BD%E9%80%A0%E5%99%A8-9928a163ac06?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/9928a163ac06</guid>
            <category><![CDATA[filmai]]></category>
            <category><![CDATA[minimax-h3]]></category>
            <category><![CDATA[ai-video-creator]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Sat, 29 Aug 2026 08:41:21 GMT</pubDate>
            <atom:updated>2026-08-29T13:59:57.577Z</atom:updated>
            <content:encoded><![CDATA[<h3>Crap Film Maker — 廢片製造器</h3><p><em>One line in, a short film with its own sound out — made on one box in my flat. A follow-up to </em><a href="https://vxrl.medium.com/my-cast-a-home-movie-studio-0d3a5c3449ee"><em>My Cast — a home movie studio</em></a><em>, and the same rule: nothing leaves the LAN.</em></p><p>researcher: {alanh0}</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*EkAcbaegLi_7-qjHnZ5L2Q.png" /></figure><p>Seedance 2.5 is very good. It is also, at the time of writing, <a href="https://openrouter.ai/bytedance/seedance-2.5">about $0.10 a second at 480p</a> (or you can use film make like <a href="https://www.liblib.tv/">liblibtv</a> which is much more professional) and rather more at 4K — metered, cloud-side, someone else’s queue and someone else’s content review. That’s a perfectly reasonable trade for most people. The four films below would have cost me two to four dollars apiece on it, and arrived in minutes rather than hours.</p><p>I wanted the other trade. On my LAN I run MiniMax-H3, which I wrote about last time and still rate — but which is, fundamentally, a six-to-eight second engine. Past about eight seconds it stops holding a scene together: people gain limbs, the room rearranges itself, and the person who walked in is somebody else by the end.</p><p>So the question this project asks isn’t <em>how do I make MiniMax generate longer video.</em> It’s:</p><blockquote><em>What has to be true around a six-second model before six-second clips add up to a film?</em></blockquote><p>The app is called CastTV. On screen it calls itself Crap Film Maker / 廢片製造器, which is honest about the output and quite misleading about the work.</p><h3>Why a second app</h3><p><a href="https://vxrl.medium.com/my-cast-a-home-movie-studio-0d3a5c3449ee">Last time</a> I wrote about My Cast, a chat app that had grown a Scenery Creator: type a line, get one clip with its own sound, then extend it by animating its last frame until six seconds had become twenty-four. I liked it a lot. It is also, looking back, the wrong shape for what I actually wanted, in two ways.</p><p>It was a mode, not a tool. It lived beside the companions and the assistant, and everything around it — the data model, the screen, the whole app — was built for a conversation. A conversation has one message after another. A film has a <em>cast</em>, an <em>order</em>, and a version of every shot you might want to go back to.</p><p>And extending is not editing. Chaining clips off the last frame keeps the join invisible, and that’s genuinely the nicest thing about it — but each new clip re-derives everyone’s face from a picture that has already drifted a little, so the drift compounds instead of cancelling. Three extensions in, the lead is somebody else, and there is nothing you can do about it from inside a mode whose only verb is <em>continue</em>. I ended that post noting exactly this trade and saying the answer was to cast the next shot rather than continue it. This app is that sentence taken seriously.</p><p>So the incentive, honestly stated: I wanted to find out whether a machine in my flat could make something with a beginning, a middle and an end — the same people in it at the end as at the start, in the same room, saying words you can make out — rather than one very good six-second moment. That is a completely different problem from generating video, and almost none of it turns out to be about the video model.</p><p>The name is the other half of the incentive. Aiming at “crap films” rather than at <em>cinema</em> is what made it finishable: it gave me permission to ship something whose output I could laugh at, and get on with the part that was actually hard. 廢片 is an achievable target. It turns out to be a surprisingly demanding one.</p><h3>1. A Chinese fable, told by a narrator — 狐假虎威</h3><p><a href="https://www.youtube.com/watch?v=B5mnN53cv44">https://www.youtube.com/watch?v=B5mnN53cv44</a></p><p><em>Five shots · 36.5s · one bamboo wood, two animals, one narrator.</em></p><p>The tiger catches the fox. The fox bluffs. The animals scatter — and the tiger, who is the one they’re actually running from, takes the fox’s word for it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*PCJNyVVVlCtt8ZgU74KZbA.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*ntbjQD66UY-aEoZzLQPdBw.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*K0wE1_2SFQ_67mussxySxA.gif" /></figure><p>Same fox, same tiger, five separately-rendered clips, one Cantonese storyteller over all of them.</p><p>Two things in there took real work and don’t look like anything. The animals are the same two animals in every shot — that is the whole problem this app exists to solve, and it is not what you get for free. And the narration is narration: nobody’s mouth moves. Told to deliver a line, this model animates a mouth, and a fable staged as dialogue comes back as a talking-animal cartoon. A voice that belongs to nobody in the picture is the <em>opposite</em> staging from a voice that belongs to somebody in it, and nothing in the words themselves can tell you which one you meant.</p><p>Now the flaws, because you will see them the moment I point at them. In the third shot there are two tigers — the real one walking behind the fox, and a pale second one drifting along at the back of the frame among the deer, which are themselves about half there. That shot’s prompt states that there is exactly one of each animal, in plain words, more than once. It wasn’t enough. And the narrator isn’t quite the same narrator all the way through: the voice shifts a little between shots — warmer here, a touch higher there. That one is a partial win rather than a loss. Before the film described its own narrator in identical words in every shot, a five-shot fable came back with shot 3 read by an audibly <em>different person</em>, mid-story. Now it’s the same reader having a slightly different day, which is the sort of progress this whole project is made of.</p><h3>2. A sitcom scene, with dialogue and a laugh track</h3><p><a href="https://www.youtube.com/watch?v=hDUow1xuXTM">https://www.youtube.com/watch?v=hDUow1xuXTM</a></p><p><em>Three shots · 24s · two people, one room, three laughs.</em></p><p>Dana has been paying the rent on an apartment Marcus owns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*lpQ1GosyKxeIkqG4XHoISw.gif" /></figure><p>This is the app’s hardest case: two faces held across two cuts, both of them speaking audible English, over a studio audience. For most of this project you could have the faces <em>or</em> the sound, and not both — more on that below.</p><p>It’s also the film I rewrote most, and none of the rewriting was technical. The first version had her feeding fish in a tank that never had any: the right <em>shape</em> of joke with nothing at stake, so the topper was a puzzle rather than a disaster, and nobody laughs at a puzzle. Rent, paid in cash, every month, on an apartment he owns — and a third shot that asks who’s been collecting it — is the same three beats with something to lose. The tool can hold a scene together. It cannot make it funny.</p><p>Its flaw is a prop. The whole joke turns on one biscuit tin, and by the last shot there are two of them: Marcus is holding it, and a second one has appeared on the coffee table in front of him. There is a clause in that prompt about precisely this — every object in frame is one whole thing, one of each, and a lid is either open or shut and not both — and it lost. Objects the story depends on are, it turns out, exactly as prone to being drawn twice as tigers are. The room drifts a little too: watch the couch lighten and the coffee table drop between shots.</p><h3>3. An anime short, in Cantonese, with a subtitle nobody asked for</h3><p><a href="https://www.youtube.com/watch?v=8pwEfjPPvs8">https://www.youtube.com/watch?v=8pwEfjPPvs8</a></p><p><em>Six shots · 35.3s · drawn, not photographed · one character.</em></p><p>Kenji wants ramen. Kenji finds a cup noodle. Kenji is happy about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*4KMYUJKTGBWoCY_EehtHyw.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*nfl7Ronvux2QnOUA83ajyA.gif" /></figure><p>The Chinese caption in the first shot is painted by the video model as picture — no overlay, no subtitle track, no ffmpeg. It is also, entirely, the model ignoring me. That shot’s prompt ends with a flat ban on text, captions and watermarks, and it drew one anyway, correctly, in glyphs it lifted from elsewhere in the prompt. I’ve left it in because it’s the truest thing in the post: you are negotiating with this model, not configuring it.</p><p>The film’s actual job is to prove that drawn is an axis of its own, not a style you layer on top. Every cinematography word — anamorphic lens, film grain, motivated practicals — is a photographic instruction, and a cartoon needs those <em>gone</em> rather than outvoted.</p><p>Its flaw is what a fixed shot length does to you. Kenji says his line about four seconds in and the shot is six, so the last second and a half is a freeze — not a held frame for effect, just a drawing sitting there because the clip hasn’t run out yet. It happens again at the end of the second shot. A shot’s length is chosen before anyone knows how long its content actually takes, and when the content finishes early the model doesn’t wrap up; it waits.</p><h3>4. Two Tang poems, recited to camera</h3><p><a href="https://www.youtube.com/watch?v=B4kPTDa1jgI">https://www.youtube.com/watch?v=B4kPTDa1jgI</a></p><p><em>Two shots · 20.3s · one long unbroken take each.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*wr4wQgAchu26okxp9zlheQ.gif" /></figure><p>Two ten-second takes, each a complete poem — title, author, a beat, then the verse — in Cantonese.</p><p>In the last post I described this model’s speech as <em>“something with the cadence of speech, in roughly the right emotional register, that isn’t words.”</em> That was accurate. Getting from there to a Tang poem you can follow took one architectural discovery and one very boring measurement, and both are below.</p><p>Its flaw is the edit. Both takes are the same setup on the same angle, each slowly pushing in — so at the ten-second mark the film cuts from a close-up straight back out to a medium and starts pushing again. That reads as a mistake rather than as an edit, and it is one: nothing chose that join, it’s just where one render stopped and the next began. The delivery is also one note all the way through. It gets the words out, in order, audibly, in Cantonese, which two months ago it could not do at all — but nobody would call it a reading.</p><h3>What it’s like to use</h3><p>You type one line and press a button. Everything after that is the app’s job: work out who’s in it, make them a face, break the line into shots, write each shot, render each shot, cut them together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n_qXe4eqEfPTTEY0yL9pZA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8TWw6f2btZjPTVAmX9hxNA.jpeg" /></figure><p>Then you get a workspace — the script on the left, the storyboard in the middle, the shot you’re working on down the right — and from there it’s much more like a production office than a prompt box. You cast people into individual shots. You set a shot’s size, angle, move, lens and length as <em>fields</em>, not as adjectives buried in a paragraph. You type the line somebody says. You render one shot, look at it, and render it again if it’s wrong — the old take is kept, and you choose which one is in the film.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*huz4Kps6-usLAcujHI7E1Q.jpeg" /></figure><p>The design principle, if there is one: nothing a model writes is applied unseen. The shot list, each shot’s prompt, each character’s description — all proposed, all shown, all editable before anything reaches the GPU. A wrong sentence in a character description is repeated verbatim in every render of every shot they’re in, and a render is minutes. The cheap moment to catch it is on screen.</p><h3>The one idea worth knowing</h3><p>A shot is 6–8 seconds, and length comes from more shots.</p><p>That’s not a limitation being worked around; it’s the design. Two things fall out, both good:</p><ul><li>Peak GPU load stays flat. A forty-second film costs more wall-clock, not more GPU at once — which, on a box that once switched itself off mid-render, is the difference between finishing and not.</li><li>A wrong shot costs one shot. Re-render it. The rest of the film is untouched.</li></ul><p>What it costs is that the film cuts rather than flows. Films do that anyway. But the bill arrives immediately, and the entire rest of the project is about paying it: <em>the same people, the same room, the same light, on the other side of the cut.</em></p><h3>The hard part is everything either side of the cut</h3><p>Here is the honest summary of two months: almost none of the difficulty was in generating video. It was in the bookkeeping around it — and I found essentially all of it the same way, by rendering something, watching it, and discovering it was wrong in a way I hadn’t thought to worry about.</p><p>A sample of the failures, because the failures are the interesting part:</p><p>The lead becomes somebody else. A twenty-shot film with nobody explicitly cast came back with a different man playing the lead from shot 15 and a different shop from shot 17. Nothing was broken. Each shot simply re-derived its people from words, and small errors compound when each generation becomes the next one’s ground truth.</p><p>The room mirrors. Two shots of one location, the same reference photograph in both, a prompt promising the same architecture, surfaces and light — every word of it honoured — and the fish tank moved from over his shoulder to over hers. Not one of those words is about <em>where anything is</em>. A photograph shows a layout without ever asserting one, which is the one door a reference image cannot close.</p><p>The jacket comes back on. Somebody takes their jacket off on screen, and the next shot is still written from the casting description, so the model puts it back. Fixing that means the app has to <em>watch its own footage</em> and notice what changed — and then be sceptical about what it noticed, because a wardrobe question asked of a close-up is a question the frame cannot answer.</p><p>A dog appears. A film whose one-line idea mentioned dogs put two of them into a shot about a man typing alone. Nothing broke a rule, because the rule was worded about <em>people</em>, which leaves a hole exactly the width of a dog.</p><p>A second tail / two foxes appears. A fox came back with two of them. A creature is a shape the model assembles, and any part whose number isn’t fixed is a part it may draw twice — which extends to the whole creature, as the fable’s third shot above demonstrates, and to props, as the sitcom’s biscuit tin does. Counting things out loud in the prompt helps and does not settle it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/516/1*9ooS14aws_IEumRda76-_w.png" /></figure><p>A creature that is not a person appears. Send one subject two near-identical full-length reference photos and you can get a large black quadruped standing behind her, legs either side. It survived a fresh seed and it survived turning reference fidelity up. Re-rendered with <em>one</em> reference, the shot came back clean. Wording could not buy it back — rephrasing made it worse, and briefly made it two of them. Nothing outranks a reference except another reference.</p><p>Every one of those has a mechanism behind it now, and I’m going to leave the mechanisms where they are. The general shape is the useful part: the things that must not drift are stored as data and stamped into the prompt, not written by a model each time, because a model handed the same instruction twice will phrase it differently the second time — and identity, place and a stated lens are exactly the things that cannot survive being rephrased.</p><p>That’s the boring lesson, and it’s the whole ballgame.</p><h3>And the very boring measurement</h3><p>Three renders of “testing 1 2 3 4”, one variable each:</p><ul><li>As-is: a second of gibberish, then the four words, clearly.</li><li>With the turbo LoRA (which exists precisely because the audio half of the latent starves first): <em>the same second of gibberish.</em> So it was never sampler quality.</li><li>Telling the prompt when the words happen, nothing else changed: clean, from the first frame.</li></ul><p>The prompt had said she “begins to speak” and never said <em>when the words were</em>, so the model generated speech-shaped audio immediately and only locked onto the actual line once it had settled. Every published guide for this model says the same thing — roughly 2.5 words a second, leave silence at both ends — and I’d read that and not implemented it, because it sounded like advice rather than a requirement. It’s a requirement.</p><p>That single change is most of the difference between the poem in the last post and the poem in this one.</p><h3>Speed, and what it costs</h3><p>Everything runs on an ASUS Ascent GX10 on my LAN — the same box that serves the chat app — at 480p, with the GPU clock capped (nvidia-smi -lgc 0,1200, the fix from last time, still holding after several hundred renders).</p><p>The rule of thumb that has held across every film here: roughly a minute of GPU per second of finished video. An eight-second shot is about eight minutes of rendering. A thirty-second film is about half an hour.</p><p>On top of that, and mostly not on top of each shot:</p><ul><li>The writing. Reading a cast out of your one line, giving each character a description, breaking the line into shots and writing each shot’s prompt — a local LLM, a few minutes, once, at the start.</li><li>The faces. About a GPU minute per character picture, once. (None of the four films above paid this: their casts ship with the app.)</li><li>A still per shot, which is the trick described above, and which is why a shot takes a bit longer than its own clip does.</li></ul><p>So a three-shot sitcom is most of a lunch break and a five-shot fable is an hour or so. This is a <em>set it going and come back</em> tool: the queue survives closing the tab, the run picks itself back up after a restart, and a film that’s rendering locks itself so you can’t edit the shots out from under it.</p><p>For comparison, the fable is 36.5 seconds — about $3.75 on Seedance, done while you make coffee. I’m not going to pretend the economics are the point. The point is that nothing left the house, nobody metered it, no queue was shared, no policy filter had an opinion, and every knob is mine.</p><h3>Limitations — read this part before you get excited</h3><p>Shot-to-shot consistency is the unsolved one. Everything here is aimed at it, and it is <em>better</em>, not solved — which is why every film above has a paragraph admitting what’s wrong with it. A duplicated tiger, a duplicated tin, a room that lightens between shots, a narrator who isn’t quite the same narrator. You stop noticing most of it in motion, which is a statement about attention rather than about quality.</p><p>Cast consistency is good and not perfect. The measurement that made me keep going: one film, rendered twice — with a proper cast, the same faces held across every cut; without one, the lead had changed by shot three. That’s a real result and it’s also a sample size of one. How far it holds with four characters, in a drawn medium, across a dozen shots, or from a photograph you brought yourself, is genuinely unmeasured.</p><p>It’s slow. A minute of GPU per second of video means a three-minute film is a three-hour render, before you re-do anything — and you will re-do things.</p><p>480p is the practical ceiling here. The app offers more; my power budget doesn’t. Fast motion goes mushy and fine detail smears, and that’s the honest local-vs-cloud gap: same model family, a fraction of the resolution.</p><p>Speech works now and is still the fragile lane. Short lines, bounded and timed, come back audible. A paragraph still comes back as mush.</p><p>Length needs a story, not a logline. The first twenty-shot film I attempted was a one-sentence idea — a night baker proves the dough, shapes the loaves, fires the oven, opens the shutter at dawn. That’s four story beats. The breakdown wrote them beautifully and then invented sixteen more shots to reach the count, complete with people the film had no reference for. A long film needs a treatment. Nothing in the app can supply that, and nothing in any app can.</p><p>It’s still a generator, not an editor. Re-render, choose takes, trim the ends, reorder, pick what exports. You cannot cut inside a take, dissolve, grade, or touch the mix.</p><p>You may professional film maker like <a href="https://dreamina.capcut.com/ai-tool/home">https://dreamina.capcut.com/ai-tool/home</a> or <a href="https://www.liblib.tv/">https://www.liblib.tv/</a></p><h3>Where this leaves me</h3><p>The name is a joke and the output mostly earns it. 廢片 — crap films. What isn’t a joke is how much has to be simultaneously true before six-second clips read as a film: the same face on both sides of a cut, the same room, the same light behaving the same way, one narrator rather than five, the words landing inside a window that was decided before the render started, and every one of those held by something that knows what it costs when it’s wrong.</p><p>Almost none of that is model capability. It’s bookkeeping — and the reason it took months rather than weeks is that none of it announces itself. A bad film here doesn’t throw an error. It renders perfectly, on time, at the right length, and is quietly about somebody else.</p><p>The first post in this series ended by saying you don’t wait for one model to do everything; you build the orchestra. The second one built a very good six seconds. This one is what happens when the orchestra has to play the same piece a dozen times in a row and have it sound like one performance.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9928a163ac06" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Cast — a home movie studio]]></title>
            <link>https://vxrl.medium.com/my-cast-a-home-movie-studio-0d3a5c3449ee?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/0d3a5c3449ee</guid>
            <category><![CDATA[comfyui-workflow]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[minimax-h3]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[ai-video-generator]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Wed, 05 Aug 2026 12:08:55 GMT</pubDate>
            <atom:updated>2026-08-14T07:54:13.166Z</atom:updated>
            <content:encoded><![CDATA[<h3>My Cast — a home movie studio (<em>Short films with sound, generated on one box in my flat — MiniMax-H3 and ComfyUI)</em></h3><p>Researcher: {alanh0}</p><p><em>Short films with sound, generated on one box in my flat — MiniMax-H3 and ComfyUI. A follow-up to </em><a href="https://vxrl.medium.com/i-built-an-ai-companion-that-lives-entirely-on-my-home-network-chat-photos-and-video-zero-934e96259728"><em>I built an AI companion that lives entirely on my home network</em></a><em>, and the same rule: nothing leaves the LAN.</em></p><p>Last time I wrote about a local AI companion: chat, photos, and short silent clips, all generated on hardware in my flat. The video part was the weakest link. Wan 2.2 gave me five seconds of motion with no sound, and every clip was a dead end — you got what you got.</p><p>This round is a different thing entirely, and the reason is a model swap: Wan 2.2 → MiniMax-H3. My app (now called My Cast) has a third mode next to the companions and the assistant: a Scenery Creator. You type one line, it writes a full cinematic prompt, and a few minutes later you have a clip with its own audio — ambience, foley, a score. Then you can keep going: extend it, and extend the extension, until a 6-second shot has grown into a 24-second scene.</p><p>Here it is running, start to finish:</p><p><a href="https://youtu.be/FwBSKUAHs68">https://youtu.be/FwBSKUAHs68</a></p><p>This is the whole interface. A look, a length, a size — and, if you want more than one clip’s worth, a total length it reaches by joining several:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*A45JwOa1qh1zCYSec0Z6ig.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*wofOAZkzjquOY6gtgA5VMg.png" /></figure><p>And here’s the test case that convinced me it was working — a Cantonese wuxia gag about a delivery guy fighting a martial arts master, written as one paragraph of text into that form.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*Q2hm70CaTUUuR1H47MYCPA.gif" /></figure><p>Then extended, twice, with nothing but “continue to fight with more tricks” and “the delivery boy use kamehameha to attack”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*7uwlnf8lAchkAeaFLrBeWA.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*-SzxB8bdvBp8gkrQ4cXO8g.gif" /></figure><p>Same scene, same characters, same platform — 5.9s → 11.8s → 23.6s, each stage continuing from the last frame of the one before.</p><h3>What the Scenery Creator does</h3><p>Before the plumbing, what the thing actually is from the outside. You type a line — everything below it is the app’s job, not yours.</p><p>It writes the cinematic prompt for you. The video model (MiniMax-H3 — more on it below) responds to long, structured prompts — a look line, a scene overview, a timed storyboard, a camera note, an audio note. That’s ~400 words per clip written by hand. A local LLM (Ollama) expands your one-liner into exactly that shape, and shows it to you to read and edit before anything renders. Nothing queues until you’ve seen the prompt.</p><p>The wuxia clip above started as a paragraph of Cantonese.</p><pre>金毛獅王，呀唔係，大師兄突然打出一招崆峒派鎮山絕學七傷拳，所謂一練七傷，七者皆傷，呢鑊真攞命呀。張無忌，呀唔係，外賣仔不慌不忙，雙掌渾圓成盾，使出乾坤大挪移，將七傷拳嘅威力化解得無影無蹤...外賣仔連消帶打，大喝一聲，霎時之間，擂台鬼影重重，成個場都係外賣仔嘅身影。大師兄根本冇辦法分得出邊個先至係外賣仔嘅真身。只見大師兄眉頭一皺，計上心頭，左腳𨂽地，大叫一聲「老師公大顯威靈」，原來佢標起童上嚟喎...... 」</pre><p>What went to the model was:</p><blockquote><em>Realistic live-action cinematic look, action movie trailer: practical film photography style, anamorphic lens, shallow depth of field, film grain, volumetric atmosphere…</em></blockquote><blockquote><em>Scene overview: A delivery worker in modern gear faces a martial artist in traditional robes on a sun-drenched wooden platform…</em></blockquote><blockquote><em>Storyboard: </em><em>[0s-3s] Shot 1: high side angle: the martial artist executes a sweeping seven-palm strike… </em><em>[3s-6s] Shot 2: tight low angle: the delivery worker explodes into a rapid counter-attack…</em></blockquote><blockquote><em>Audio: sharp rhythmic impacts of fabric and breath, underpinned by a deep building orchestral score…</em></blockquote><p>Everything else in the feature falls out of that:</p><ul><li>Text → video, or photo → video (your photo becomes the first frame).</li><li>Two people from two photos — reference-to-video, where each photo is a subject rather than a frame. Upload two faces and they appear in one scene together, each keeping their own face.</li><li>Another take — same prompt, fresh seed.</li><li>Extend (+6s, +12s…) — the one I use most. It takes the clip’s last frame, renders new footage continuing from it, and joins them with ffmpeg. The seconds you already have are kept exactly.</li><li>Movie mode — ask for 30s and it renders several clips, each starting from the previous one’s last frame, and joins them. Peak GPU load stays at one-clip level; only wall-clock grows.</li><li>Bring your own footage — upload a video and continue <em>that</em>. The join normalises mismatched size, frame rate and audio presence, because ffmpeg’s concat filter refuses anything else.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*GJj0sQuDVScJUY2hiCuG5A.png" /></figure><p>A scene is a project, not a render: every take lives under it, and the metadata line says exactly what you’re looking at — <em>23.6s · extended · 2 clips of 6s, joined · 282f · 832×480</em>.</p><p>Image-to-video is the other half of it, and it isn’t limited to photographs. Hand it a drawing and it animates the drawing:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*eKmFiuaeZoYBMT3KFaG3lQ.png" /></figure><p>Result:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*bOzbPMSyyeWkd4xxNJtWOA.gif" /></figure><p>Four and a half seconds, 480×704, with its own audio — from one still image and a sentence.</p><p>That’s the product. The rest of this post is how it’s built, why it nearly cooked my machine, and what it still can’t do.</p><h3>What MiniMax-H3 actually is</h3><p><a href="https://www.minimax.io/blog/minimax-h3">MiniMax-H3</a> is billed by its authors as a “general-purpose multimodal generation model” that “understands unified context across text, images, video, and audio” — text-to-image, image editing, audio, and video all from one model. What matters for my purposes is the video half, and its party trick: video and audio come out of the same latent.</p><p>There’s no separate TTS or sound-effects pass. You decode the sample twice — once through a video VAE, once through an audio VAE — and mux the two. A clip of rain arrives with the sound of rain already in it. MiniMax describes it as “native stereo sound… up to 15 seconds at 2K resolution”, with no separation between voice, sound effects and music. (2K is their cloud service. On my hardware, read on.)</p><p>Three modes, all built on the same checkpoint family:</p><ul><li>t2v — text → video + audio</li><li>i2v — a start frame + text → video + audio</li><li>r2v — several <em>reference images</em> (subjects) + text → video + audio</li></ul><p>Practical constraints worth knowing up front, because they shape everything downstream:</p><ul><li>Output is 24 fps, and the frame count must sit on a 17k + 5 grid — 107, 124, 141, … 362. Ask for a number off the grid and ComfyUI rounds it <em>up</em>, silently making your render longer than you asked.</li><li>The trained range is roughly 124–362 frames, i.e. about 5 to 15 seconds.</li><li>Width and height must be multiples of 32.</li><li>It runs entirely on built-in ComfyUI nodes — no custom node packs, which after the Wan 2.2 dependency hunt felt like a holiday.</li></ul><h3>Coming from Wan 2.2: what actually changed</h3><p>My previous setup used Wan 2.2, and it earned its place — it still runs in the app for chat clips, because it’s light. But MiniMax-H3 is a step up in a way I didn’t expect to be so visible:</p><p>Wan 2.2 (before)MiniMax-H3 (now)Audionone — silent clipsnative, from the same latentShots per clipone continuous shota timed storyboard with hard cuts inside one renderSubjects from photosone start framestart frame or several reference subjectsCustom nodesComfyUI-WanVideoWrapper requirednone — all built-inSampler steps4 (Lightning LoRAs)20 reference, 8 hereCostlighter — an occasional shutdownheavy enough to fail almost every long render</p><p>The second row is the one that changed how I use it. Wan gives you a single continuous shot; you prompt for motion and get motion. MiniMax will take a storyboard with timestamps — [0s-3s] Shot 1: high side angle… [3s-6s] Shot 2: tight low angle… — and cut between those shots inside a single render. That&#39;s why the app writes a storyboard rather than a description: you&#39;re not prompting a clip, you&#39;re prompting a sequence.</p><p>Add a soundtrack that arrives with it, and the output stops feeling like a tech demo and starts feeling like footage. The price is everything in the rest of this post: it’s roughly 5× the sustained GPU work, and that’s what nearly cooked my machine.</p><h3>The hardware, and the weights</h3><p>Everything runs on an ASUS Ascent GX10 on my LAN — the same box that serves Ollama for the chat side. It has enough unified memory to hold the whole MiniMax stack resident, which turns out to be both the reason it works and the reason it got hot (more on that shortly).</p><p>The weights come from <a href="https://huggingface.co/Comfy-Org/MiniMax-H3">Comfy-Org/MiniMax-H3</a> on Hugging Face. Note there&#39;s no split_files/ prefix in this repo, unlike the Flux ones:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P7rTrsfCa4NpTC0X5AVV9w.png" /></figure><pre>cd ComfyUI/models<br>B=https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main<br>wget -c -O diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors &quot;$B/diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors&quot;<br>wget -c -O text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors        &quot;$B/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors&quot;<br>wget -c -O vae/minimax_h3_video_vae_fp16.safetensors                         &quot;$B/vae/minimax_h3_video_vae_fp16.safetensors&quot;<br>wget -c -O vae/minimax_h3_audio_vae_fp32.safetensors                         &quot;$B/vae/minimax_h3_audio_vae_fp32.safetensors&quot;</pre><p>That’s ~42 GB for t2v/i2v, or ~63 GB if you also want r2v. The text encoder is a 32B qwen3-VL — bigger than the diffusion model itself, and a large part of why this is heavy to run.</p><p>Notice what that adds up to: ~42 GB resident, with no offloading. Hold that thought.</p><h3>ComfyUI template → API JSON → my app</h3><p>I didn’t write the graphs. ComfyUI ships MiniMax-H3 templates (Workflow → Browse Templates → Video), and they’re good — the t2v one in particular comes with a beautifully written example prompt that taught me more about prompting this model than any documentation did.</p><p>The workflow is:</p><ol><li>Load the template, hit Run, confirm the models are all found.</li><li>Tweak until a render looks right <em>by hand</em>.</li><li>Workflow → Export (API) — this is the format that can be POSTed to /prompt.</li><li>Drop the .api.json into my app&#39;s workflows/ folder and pick it in Settings.</li></ol><p>My app never opens ComfyUI’s UI. It reads the API JSON, patches a handful of values into it, POSTs it to /prompt, follows progress over the WebSocket, and reads the finished file off disk. The important design decision: which node carries which value is detected from the graph, not hardcoded. A Flux prompt lives on CLIPTextEncode.text, a Wan seed on WanVideoSampler.seed, a MiniMax prompt/size/length all on one MiniMaxH3ImageToVideo node — the app introspects by node class, so swapping in a different workflow file doesn&#39;t need a config edit.</p><p>Two things about the official templates caught me out, and they’re worth flagging if you go the same route:</p><p>Subgraphs produce composite node ids. Export a template built with subgraphs and your node ids come out as &quot;105:104&quot; rather than &quot;104&quot;. Harmless if you&#39;re detecting bindings, fatal if you hardcoded ids.</p><p>The interesting values aren’t literals. In the cinematic templates, width and height come out of a ResolutionSelector node, and the frame count comes out of a MathExpression fed by a &quot;duration in seconds&quot; float. So the two knobs I most wanted to control — size and length — weren&#39;t patchable values at all; they were computed by the graph.</p><p>My general rule is <em>never overwrite a field that’s wired to another node</em> (it’s computed, and writing to it does nothing). But here that rule blocked the whole feature. The fix was a narrow, explicit exception: for node classes where I know the field is really a widget — MiniMaxH3ImageToVideo.width/height/length, proven by ComfyUI&#39;s own flat templates using them as plain values — the app writes a literal straight over the link. The upstream helper nodes are simply orphaned, and ComfyUI never executes them. One deliberate rule-break, documented at the point where it happens.</p><h3>The hurdle: a GPU that switched the machine off</h3><p>First real render at the template’s reference settings — 20 steps, 124 frames, 832×1248 — and the box powered off. Not a crash, not an OOM. Off.</p><p>In fairness, this wasn’t new. Wan 2.2 had done it too, just rarely enough that I’d filed it as a curiosity — a long render every now and then that ended with the machine dark. MiniMax turned that occasional glitch into something close to reliable, which is what finally made me diagnose it properly instead of shrugging and re-running. The difference between the two isn’t size, it’s sustained draw:</p><ul><li>Wan runs 4 sampler steps (thanks to Lightning LoRAs) and offloads its high/low-noise models sequentially.</li><li>MiniMax ran 20 steps with ~42 GB resident and no offloading.</li></ul><p>Roughly 5× the sustained work — a power/thermal envelope problem, not a memory one. journalctl -b -1 after a reboot confirmed there was no OOM kill, no Xid error, nothing in dmesg: the machine simply stopped. That&#39;s the signature of hitting a power or thermal limit rather than anything software can catch, which is also why the rare Wan shutdowns had never left a trace worth chasing.</p><p>The fix that actually solved it was capping the GPU clock:</p><pre>sudo nvidia-smi -lgc 0,1200</pre><p>Locking the graphics clock to a 0–1200 MHz range takes the top off the power spikes. Renders got maybe 10–15% slower and became completely stable — a trade I’d take every time on a machine that has to sit in a cupboard and behave. It fixed the Wan shutdowns as a side effect, which is how I know the diagnosis was right: same cap, two models, no more dark machine.</p><p>The number I watch now is not the temperature itself:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mTF53GfmDTc7_Svfca0guQ.png" /></figure><pre>watch -n 5 nvidia-smi -q -d TEMPERATURE</pre><p>On this GPU, T.Limit is the margin, not a temperature — it&#39;s how many degrees are left before throttling, and it counts <em>down</em> toward zero as the card heats. In that capture the GPU is at 58 °C with 36 °C of headroom left; Shutdown T.Limit -5 C means the shutdown point sits five degrees past the limit. Watching GPU Current Temp alone would have told me almost nothing — 58 °C sounds fine, and 58 °C on a box with 2 °C of margin left is a machine about to switch itself off. Every default in the app (8 steps, 480p, the 12-second cap, the cooldown, one render at a time) exists to keep that number comfortably positive.</p><p>Alongside that, the app is conservative by default:</p><ul><li>8 sampler steps instead of 20. This is the biggest lever on sustained draw. MiniMax isn&#39;t a distilled model, so 8 is genuinely lossy — but it&#39;s the difference between finishing and falling over.</li><li>480p by default (the app computes size from megapixels + aspect, snapped to /32).</li><li>A 12-second cap, below the model&#39;s own 15s ceiling.</li><li>A cooldown between chained clips, because chaining caps the <em>peak</em> load but not accumulated heat.</li><li>One render at a time, through a single background worker. Two clips at once is exactly the situation the box can&#39;t survive.</li></ul><h3>Limitations — read this part before you get excited</h3><p>I like this feature a lot, and it is nowhere near a video tool you&#39;d ship a film with.</p><p>Speech doesn&#39;t work — at least not here. The audio is genuinely impressive for ambience, foley, impacts and score. Voices are not: you get something with the <em>cadence</em> of speech, in roughly the right emotional register, that isn&#39;t words. There&#39;s no lip-sync control and no way to specify dialogue. MiniMax&#39;s own materials make no distinction between voice, effects and music, so some of this may simply be what 8 sampler steps at 480p buys you rather than a hard limit of the model — but on my hardware, treat the soundtrack as atmosphere, not performance.</p><p>It&#39;s slow. At 480p, a 12-second clip takes about 10 minutes on this box. A 24-second scene built from extensions is three renders plus cooldowns — closer to half an hour. This is a &quot;set it going and come back&quot; tool, which is exactly why the app runs renders in a background queue that survives you closing the tab.</p><p>480p is the practical ceiling here. The app offers 720p and 1080p, and MiniMax&#39;s own service advertises 2K — but every step up roughly doubles the cost, and the thermal headroom I bought with the clock cap gets spent immediately. This is the clearest illustration of the local-vs-cloud gap: same model weights, a fraction of the resolution.</p><p>8 steps is visibly lossy. Fast motion goes mushy, fine detail smears. The model can do better; my power budget can&#39;t.</p><p>Continuity drifts. The last-frame hand-off is remarkably good — the join is usually invisible — but small changes accumulate across several extensions, and the <em>audio</em> can&#39;t be continuous at all, since each clip generates its own soundtrack independently. I fade 80 ms either side of a join to hide the click; that&#39;s the honest limit.</p><p>Identity across shots: continuity or the face, not both. i2v takes a start frame and no reference images; r2v takes reference images and no start frame, and no node does both. Animating the last frame keeps the join invisible, but the model is never shown a photo of <em>who this person is</em>, so each shot re-derives the face from a picture that has already drifted — by the third clip the lead is somebody else. So continuations are cast, not continued: the next shot is rendered with r2v from the character’s own photograph, and the join becomes a cut instead of an unbroken take, with the continuity moved into the words (same room, same light, same wardrobe, new angle). That’s the trade an editor makes all day, and I’ll take it over a rotating cast of strangers.</p><p>No exact identity in continuations. i2v takes a start frame and no reference images; r2v takes reference images and no start frame. No node does both. So bringing a new character into an extension means compositing them into the last frame first, which carries <em>what the photo shows</em> rather than an exact face.</p><p>No editing. You can extend, re-roll and delete. You can&#39;t trim, cut, reorder or adjust timing. It&#39;s a generator, not an NLE.</p><p>Text is off the table. These models can&#39;t render legible text, so the prompt template explicitly forbids captions, logos and subtitles rather than producing garbled ones.</p><h3>Where this leaves me</h3><p>The companion app was about presence — someone to talk to that never phones home. This is about production: a small studio that turns a sentence into a scene with sound, on hardware I own, with no per-second billing and no content review queue.</p><p>The gap to a commercial tool is real and I&#39;ve listed it above. But the direction of travel is what strikes me. A year ago, local video generation meant a silent, three-second, 256px curiosity. Today I can describe a wuxia gag in Cantonese and get back 24 seconds of scene with an orchestral score attached — for the price of ten minutes of electricity.</p><p><em>My Cast is a local-first AI studio: companions, a general assistant, and the Scenery Creator. Ollama for language, ComfyUI for pixels, everything on the LAN. Demo: </em><a href="https://youtu.be/FwBSKUAHs68"><em>youtu.be/FwBSKUAHs68</em></a><em> · Model: </em><a href="https://www.minimax.io/blog/minimax-h3"><em>MiniMax-H3</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0d3a5c3449ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Bug Hunting]]></title>
            <link>https://vxrl.medium.com/ai-bug-hunting-1d1398b229cd?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d1398b229cd</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[secure-coding]]></category>
            <category><![CDATA[bug-hunting]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Thu, 23 Jul 2026 11:12:02 GMT</pubDate>
            <atom:updated>2026-07-23T11:12:02.397Z</atom:updated>
            <content:encoded><![CDATA[<p>Our lab has developed an AI bug-hunting platform. This is a team with software developers, cybersecurity and vulnerability researchers, Blockchain and Smart Contract security analysts, an AI researcher, and a DevOps engineer. The entire team can hunt bugs and take bounties.</p><p>For my role, I&#39;m excited to put my software developer hat back on to develop the platform and the algorithm, and to plan the skills/RAGs/Expert/KB/Payload collection. Let us share more details here for your reference:</p><h3><strong>AI Bug Hunt — Executive Summary</strong></h3><p><strong>AI Bug Hunt</strong> is an autonomous, role-driven security-research agent that hunts real vulnerabilities across four target classes:</p><ul><li><strong>Source code (SAST)</strong> — local trees, GitHub repos, and pull requests</li><li><strong>Compiled binaries (reverse engineering + exploitation)</strong> — Ghidra decompilation, angr symbolic execution, and pwntools-driven exploit development (ROP, format-string, shellcode, ret2libc). Capable of working end-to-end on a binary to <strong>build a working exploit and capture a CTF flag</strong>.</li><li><strong>Mobile app packages</strong> — .apk / .aab / .ipa / .app</li><li><strong>Live web apps (DAST)</strong> — real Chromium via Playwright, scope-gated</li></ul><p>It is fully <strong>self-hostable</strong>, <strong>multi-provider</strong> (bring your own LLM key or run offline against Ollama), and ships with a SQLite session store, a web dashboard, GitHub PR/Actions integration, and a bundled pwntools-based exploitation toolkit.</p><p>The design philosophy mirrors Theori XInt’s: <em>frontier models are strong at vulnerability research when you give them a real harness</em> — tools to read code, run scripts, drive a browser, talk to Ghidra, and persist memory across turns. The pipeline <strong>is</strong> that harness; markdown role files are the specialist personas; the deterministic stages are guardrails on cost.</p><p><strong>Key facts</strong></p><ul><li><strong>Pipeline stages</strong>: 15 (deterministic preprocessors + always-on agent stages)</li><li><strong>Orchestration modes</strong>: 4 (legacy, coordinator, glasswing, langgraph)</li><li><strong>Specialist skills</strong>: 44 core skills + 14 named expert personas</li><li><strong>Pre-built playbooks</strong>: 12 (full-audit, web-only, pr-review, api-security, crypto-audit, supply-chain, …)</li><li><strong>Decision rubrics / framework FP filters</strong>: 17 vuln-class rubrics + 13 framework false-positive patterns</li><li><strong>LLM providers</strong>: 6 (Gemini, OpenRouter, OpenAI, Anthropic, GLM/Z.ai, local Ollama)</li><li><strong>Knowledge base</strong>: 16 curated attack-class references + continuously-crawled RAG vector store</li><li><strong>Deployment</strong>: Single self-hosted process; CLI + web dashboard; no SaaS dependency; runs fully offline on Ollama</li></ul><p><strong>The problem it solves</strong></p><p>Failure mode: Pattern-matching SAST drowns reviewers in unprioritised noise</p><p><strong>How this project answers it</strong>: Deterministic scanners feed an <strong>agentic triage</strong> loop that assigns verdicts, CWE, and CVSS — and an adversarial <strong>critic</strong> pass kills false positives before exploit tokens are spent.</p><p><strong>Failure mode: Pure-LLM scanners lose context past a few thousand lines</strong></p><p><strong>How this project answers it</strong>: A <strong>funnel</strong> of deterministic preprocessors (regex / scanner / symbolic execution) narrows candidates <em>before</em> the LLM is invoked, and a structural <strong>memo</strong> keeps architectural context across turns.</p><p>Failure mode: Both miss business-logic flaws that live in no signature DB</p><p><strong>How this project answers it</strong>: A dedicated business-logic skill plus the agent&#39;s ability to <strong>write and run its own scripts</strong> find state-machine and invariant bugs that pattern-matchers can&#39;t.</p><p><strong>Our approach: harnessed, not hands-off</strong></p><p>The system is deliberately positioned between two weaker extremes, and is not either of them:</p><ul><li><strong>Not a free-running chatbot.</strong> We do not hand the job to a general LLM assistant (Claude Code, Codex, a chat window) and let it improvise. Every step runs inside a constrained harness — fixed stages, scoped tools, token and tool-call budgets, completeness checks on findings, and an adversarial critic — so the model works within a defined methodology rather than wherever its attention drifts.</li><li><strong>Not just a scanner wrapper.</strong> We do not simply run CodeQL / Semgrep / Ghidra and forward their output. Those tools are the cheap first filter; the value is added on top of them.</li></ul><p>What sits in between — and is the actual product — is the encoding of <strong>how expert researchers work</strong> into the harness:</p><ul><li><strong>Methodology</strong> — the staged funnel, the triage rubrics (17 vuln-class decision guides), and the framework-specific false-positive patterns (13 of them) reflect how a senior reviewer reasons about each bug class, not a generic “look for bugs” prompt.</li><li><strong>Field experience</strong> — 44 specialist skills and 14 named expert personas (HTTP desync, heap, JS-engine/JIT, kernel, SSO chains, cloud IAM, crypto, CI/CD, …) carry the techniques and gotchas of the disciplines they model.</li><li><strong>Curated knowledge</strong> — 16 attack-class reference documents plus a continuously-crawled RAG knowledge base keep the agent grounded in current, published research from leading researchers and venues — so conclusions are backed by established technique, not the model’s training-data guesswork.</li></ul><p>In short: deterministic tools provide the signal, published research and our own methodology provide the judgment, and the harness keeps the LLM applying that judgment consistently — instead of letting a chatbot decide the approach on its own.</p><p><strong>Architecture at a glance</strong></p><p>The pipeline is a <strong>funnel of deterministic preprocessors interleaved with always-on agent stages</strong>. Deterministic stages drop candidates cheaply; agent stages reason, exploit, and prioritise.</p><p>Inputs</p><ul><li>GitHub repo / PR -&gt; clone -&gt; narrow to diff -&gt; post review</li><li>Source / binary -&gt; Stage 1 Ingestion</li><li>Mobile package -&gt; Stage 1 Ingestion</li></ul><p>Pipeline Flow</p><ul><li><strong>Stage 1</strong>: Scanner ingestion (CodeQL / Semgrep / Ghidra)</li><li><strong>Stage 1.1</strong>: CodeQL taint-path LLM verifier</li><li><strong>Stage 1.2</strong>: LLM-scan agent (always-on source review)</li><li><strong>Stage 1.3</strong>: OWASP Mobile benchmark (mobile targets)</li><li><strong>Stage 1.4</strong>: MobSF static import (optional, mobile)</li><li><strong>Stage 1.5</strong>: Binary-recon agent (Ghidra + angr + pwntools)</li><li><strong>Stage 1.6</strong>: Variant analysis (Project Zero-style clones)</li><li><strong>Stage 2</strong>: angr / CFGFast feasibility</li><li><em>(Agentic harness: Coordinator dispatches specialists)</em></li><li><strong>Stage 4</strong>: AFL++ / libFuzzer / HTTP fuzzing</li><li><strong>Stage 4.1</strong>: Web pentest (live target)</li><li><strong>Stage 4.2</strong>: Exploitability gate (skip infeasible PoCs)</li><li><strong>Stage 5</strong>: Exploit generation (deterministic builders)</li><li><strong>Stage 5.1</strong>: PoC re-verification (clean sandbox)</li><li><strong>Stage 6</strong>: Production-config review</li></ul><p>Outputs</p><ul><li>Generated reports, updates to sessions.db, GitHub PR comments, and live web dashboard view.</li></ul><h3><strong>Benchmarking</strong></h3><p><strong>Scope</strong></p><p>We carry out benchmarking on GLM-5.1 (Z.ai, flat-rate) vs Claude Opus 4.8 (OpenRouter, $5/$25 per Mtok) across <strong>6 target types / 8 batches</strong>: source (flask, cbof, baby-ROP), repo (AltoroJ), binary (Ghidra), web DAST (Juice Shop), mobile APK (allsafe), smart contract (DVD). Every finding was <strong>adjudicated by Claude Code reading the real code</strong> — 0 “uncertain”.</p><h4>Top-line</h4><ul><li><strong>Both models find real bugs in every target type</strong> — the pipeline works end-to-end on source, binaries, web, mobile, and Solidity.</li><li><strong>Precision is driven by <em>methodology</em>, not the model</strong>. Evidence-based methods score 86–100%; speculative static analysis over a large real codebase drops to ~55%.</li><li><strong>GLM is the value pick:</strong> consistently <em>tighter</em> precision, and <strong>$0</strong> (subscription) vs Opus’s <strong>~$67</strong> total. Opus has higher <em>recall</em> (finds more) but lower precision and uses <strong>3–8× more tokens</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9a58Qrdx3OfKn2kCvm1iYg.png" /></figure><h4>Why one target has most of the false positives — it’s SAST vs DAST</h4><p><strong>AltoroJ holds ~203 of the ~257 total FP</strong>, yet it is the only target scanned with <strong>SAST</strong> (static pattern-matching over a large real Java web app). Juice Shop — the actual <em>web</em> target — scored the best precision (88%) with only 2 FP. The difference is the <em>method</em>, not the app:</p><ul><li><strong>DAST (Juice Shop)</strong> — the agent <em>probes the running app</em>: sends payloads, observes responses, reports only when it <strong>sees the exploit work</strong>. Confirmation-based → <strong>high precision</strong>.</li><li><strong>SAST (AltoroJ)</strong> — CodeQL + llm-scan flag <em>potential</em> sinks across thousands of lines. On a sprawling real codebase that yields many <strong>speculative</strong> findings the judge then demoted: <strong>duplicates</strong> (same bug at adjacent lines), <strong>unhandled-exception/robustness noise</strong> (NumberFormatException → HTTP 500 ≠ a vuln), <strong>code-quality lint</strong>, <strong>framework-protected</strong> paths, and <strong>unreachable/dead code</strong>.</li><li><strong>Opus over-reports the most</strong> (285 findings / 125 FP on AltoroJ vs GLM’s 169 / 78): higher recall, lower precision — it flags aggressively on ambiguous code.</li></ul><p><strong>Takeaway:</strong> the false-positive rate is a property of <em>target size × analysis method</em>, not the model’s competence. The same models hit 88–100% precision when the method confirms exploitability (DAST, contract logic) and ~55% when pattern-matching a big codebase (SAST). For SAST on large repos, a verification/triage layer (the Claude-Code judge here, or the pipeline’s triage-critic) is what makes the output usable.</p><h4>Cost</h4><ul><li><strong>GLM: $0</strong> (flat subscription) across all 8 targets.</li><li><strong>Opus: ~$67</strong> — driven by AltoroJ ($20), flask ($19), DVD-full ($10). Opus’s token use scales with codebase size (it triages every candidate).</li></ul><p><em>Verdicts adjudicated by Claude Code (Opus 4.8) reading the actual source.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3D08c3S1gfR26Kx0lAOGhw.png" /></figure><p>We have also applied the platform to detect real-world enterprise-developed applications; the binaries and code vulnerabilities are successfully identified, and the cost can be more predictable, and it looks promising so far.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d1398b229cd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Emoji Slot Machine to Thunder Downs: Rebuilding a Horse Racing Game with Claude Fable 5]]></title>
            <link>https://vxrl.medium.com/from-emoji-slot-machine-to-thunder-downs-rebuilding-a-horse-racing-game-with-claude-fable-5-04b3db724af2?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/04b3db724af2</guid>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[claude-fable-5]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 07:33:51 GMT</pubDate>
            <atom:updated>2026-07-05T10:36:45.448Z</atom:updated>
            <content:encoded><![CDATA[<p>Researcher: {alanh0}</p><p><em>How an AI pair-programmer turned 2,485 lines of vibes into a calibrated racing simulation — in one session, with zero dependencies.</em></p><p>Play it live: <a href="https://alanh0vx.github.io/horses/horses.html">alanh0vx.github.io/horses/horses.html</a></p><h3>The starting point</h3><p>The original “Elite Horse Racing Championship” was a fun weekend build: emoji horses (🐎🐴🦄) orbiting a CSS ellipse, random odds, and a betting system you couldn’t lose at if you tried. It looked like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hlNGaCY9VAQC3KKz.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HwA7iWtKgT5tdUx1.png" /></figure><p>It worked, but under the hood almost everything was theater:</p><ul><li>Odds were pure Math.random() — 1.5 + Math.random() * 12, completely unrelated to a horse&#39;s speed or stamina stats. The &quot;live odds&quot; ticker was random noise applied to random numbers.</li><li>The betting economics were broken. Place paid a flat 1.5×, Show refunded your stake, and with average odds around 7× and no bookmaker margin, the expected value of betting was massively positive. You literally couldn’t lose long-term.</li><li>The track coordinates were hardcoded to an 800×400 layout (const x = 400 + 330 * Math.cos(...)), but the responsive CSS shrank the track to 300×300 on phones — so on mobile, horses flew off the track entirely and orbited empty space.</li><li>The race itself was one flat loop where a random factor (0.7 + Math.random() * 0.6) dominated everything. No pace, no stamina that mattered, and the race hard-stopped the instant three horses finished — the rest just teleported into their placings.</li><li>All six horses ran the <em>exact same ellipse path</em>, stacked on top of each other, distinguished only by a CSS hue-rotate() filter — which does nothing useful to emoji glyphs.</li></ul><p>I handed the whole folder to Claude Fable 5 with a one-line brief: <em>review, plan, and upgrade — better UI, UX, graphics, playable and realistic.</em> What came back is effectively a different game.</p><p>Edited: added zh-hk support</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*E5Z53QV0xzhN-xBt.png" /></figure><h3>Architecture: one file becomes four modules (still zero dependencies)</h3><p>The repo rule is strict: GitHub Pages, no build step, no npm, no CDN. Fable 5 kept that constraint and split the monolith by responsibility:</p><pre>horses/<br>├── horses.html          # structure only<br>├── horses.css           # design system w/ CSS custom properties<br>└── js/<br>    ├── engine.js        # pure logic: geometry, odds, simulation (Node-testable!)<br>    ├── renderer.js      # canvas: track, horses, camera, particles, weather<br>    ├── audio.js         # WebAudio: everything synthesized, no sound files<br>    └── game.js          # state machine, betting UI, persistence</pre><p>The key move: engine.js has zero DOM access. It ends with if (typeof module !== &#39;undefined&#39;) module.exports = Engine; — which means the entire race simulation can be executed and statistically validated in Node, headlessly, thousands of races at a time. That one design decision is what made everything else in this post measurable instead of guessed.</p><h3>The odds problem, or: how to make betting a skill game</h3><p>This was the most interesting engineering problem in the rebuild. A betting game is only fun if the odds <em>mean something</em> — favorites should win about as often as their price implies, longshots should occasionally shock, and the bookmaker should take a realistic cut.</p><h3>Step 1: Rate the horses</h3><p>Each horse gets stats (speed, stamina, acceleration, consistency, experience), a running style (front-runner / stalker / closer), and preferences for distance category, going, and weather. An effective rating blends them with distance-dependent weights — sprints weight raw speed, staying trips weight stamina:</p><pre>const WEIGHTS = {<br>  sprint:  { speed: 0.45, stamina: 0.15, accel: 0.25, exp: 0.15 },<br>  mile:    { speed: 0.35, stamina: 0.30, accel: 0.15, exp: 0.20 },<br>  staying: { speed: 0.25, stamina: 0.45, accel: 0.10, exp: 0.20 },<br>};</pre><p>Condition matches add rating points — a horse that prefers Soft going, on a Soft track, on its favorite distance, is genuinely faster today. The UI surfaces these as green ✓ badges on the race card, so <em>reading the form actually pays</em>.</p><h3>Step 2: Ratings → probabilities → prices</h3><p>Win probabilities come from a softmax over ratings (p ∝ e^(rating/6.5)), and the market price is the fair price shaded by a bookmaker overround:</p><pre>h.fairOdds = 1 / h.prob;<br>const market = clamp((h.fairOdds / 1.16) * rand(0.94, 1.06), 1.25, 60);</pre><p>That 1.16 is a ~16% overround — right in line with real-world racebooks. The pre-race &quot;live market&quot; now drifts around the fair price with mean reversion instead of pure noise.</p><h3>Step 3: Calibrate against the simulation</h3><p>Here’s where the Node-testable engine earned its keep. Fable 5 ran 400–600 full simulated races per iteration and compared actual win rates against the odds’ implied probabilities. The first attempt failed hard:</p><blockquote><em>Iteration 1: favorites won 52% of races against ~31% implied. Betting the favorite every race was free money — the exact same flaw as the original, inverted.</em></blockquote><p>The fix was tuning how much a horse’s rating moves its raceday speed versus how much day-to-day randomness (“dayForm”) it carries. After two tuning passes:</p><p>MetricTargetFinalFavorite win rate vs implied≈ equal37.7% vs 38.1%EV per $1 on the favorite0.85–0.950.87Outsider win rate vs implied&gt; 0, &lt; implied1.7% vs 2.1%EV per $1 on the outsiderworse than favorite0.55Median winning margin1–3 lengths2.1 lengthsPhoto finishes (&lt; 0.4 lengths)occasional~10%</p><p>Two details worth calling out:</p><p>The dead-longshot bug. After the first calibration pass, outsiders won <em>zero</em> races out of 400. Softmax probabilities have fatter tails than a race decided by rating-plus-Gaussian-noise. The fix was fattening the tails of dayForm itself — a 9% chance of a “big day” and 9% chance of an “off day”:</p><pre>dayForm: rand(0.968, 1.032)<br>       + (Math.random() &lt; 0.09 ? rand(0.008, 0.035) : 0)<br>       - (Math.random() &lt; 0.09 ? rand(0.008, 0.035) : 0),</pre><p>After that, longshots land about once every 50–60 races — rare enough to feel like an event, real enough that the price isn’t a lie.</p><p>The favorite–longshot bias is emergent. Favorites return $0.87 per dollar, outsiders $0.55. That asymmetry — long documented in real parimutuel markets — wasn’t programmed in. It fell out of the same tail-shape mismatch that real bookmakers exploit.</p><h3>Step 4: Real bet pricing</h3><p>Win/Place/Show now derive from the win price (place = 1 + (win − 1) × 0.34), and the higher race classes unlock Exacta and Quinella, priced from joint probabilities using the standard conditional formula:</p><pre>// P(A first AND B second) — Harville method<br>const p = a.prob * (b.prob / (1 - a.prob));<br>return clamp(0.82 / p, 4, 800);</pre><h3>A race engine with actual racecraft</h3><p>The old loop was position += speed × random(). The new simulation runs at a fixed 50ms timestep with distinct phases and mechanics:</p><ul><li>Gate break — acceleration modified by a per-race break quality roll, weighted by experience. Bad breaks happen (breakQ &lt; 0.88) and the commentator calls them out.</li><li>Running styles — front-runners go +4.5% early and pay for it late; closers concede the early lead and unleash a kick in the last 28% <em>if they still have energy</em>.</li><li>Energy model — drain scales with (v / sustainablePace)^3.6, modulated by stamina, weather, and going. Burn too hot early and the fade multiplier drags you back to 82% speed in the straight. Stamina genuinely decides races now.</li><li>Lanes and traffic — horses hold fractional lanes, pull out to overtake when blocked, drift back to the rail when clear. Running wide has a real cost: on turns, distance is scaled by R / (R + laneOffset) — cover more ground, lose more time. Sitting 2.5–7m behind another runner grants a slipstream bonus (+1.3% speed, −7% drain).</li><li>Pack compression — the subtlest tuning knob. Pure independent simulation produced realistic <em>winners</em> but ugly <em>finishes</em> (the field strung out over 30 lengths). A gentle catch-up on trailing runners and a fractional ease on clear leaders tightened the median winning margin from 4.1 to 2.1 lengths — verified to leave favorite calibration untouched (37.7% before, 39.3% after, both within noise of implied).</li></ul><p>The track itself is now parametric geometry in <em>meters</em>, not pixels: two 300m straights joined by 100m-radius semicircular turns (lap ≈ 1,228m), with a pathPoint(s, offset) function mapping distance-along-track + lateral offset to world coordinates. Race distances from 1000m sprints to 2400m staying tests all start from computed gate positions and finish at the same winning post — like a real course. The hardcoded-pixels mobile bug is structurally impossible now.</p><h3>Rendering: from CSS ellipse to a procedural broadcast camera</h3><p>Everything on screen is drawn in code — no image assets, no sprite sheets:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PaQq8r0S4l69Qd8_.png" /></figure><ul><li>The world is drawn in meters through a camera transform (ctx.setTransform(zoom·dpr, 0, 0, zoom·dpr, ...)), so the renderer and the physics share coordinates.</li><li>The follow camera computes the bounding box of live runners each frame, fits zoom to it (clamped between “whole track” and 6.5 px/m), and lerps position and zoom separately. It zooms in when the pack bunches and pulls back when the field strings out — like a TV director.</li><li>Horses are drawn top-down with procedural gallop animation: four legs phase-offset on a stride cycle driven by actual velocity, jockeys in generated racing silks (10 color pairs × 6 patterns), saddle-cloth numbers, and a screen-space number bubble above each runner.</li><li>One sneaky trick: at full-track zoom a real 2.4m horse would be ~4 pixels long. The renderer oversizes horses inversely to zoom (k = clamp(20 / (2.6·zoom), 1, 3.6)) — the same cheat every map-based racing game uses, and you never notice it happening.</li><li>Weather is physical: rain renders as wind-angled screen-space streaks, the dirt darkens when wet, dust particles trail hooves on firm going and mud splashes on soft, and the grandstand crowd — 560 procedural pixel-people — starts jumping when the field turns for home.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lLEiti-EyO3i6MWw.png" /></figure><p>The audio is equally asset-free: a brown-noise buffer filtered into gallop hits scheduled against the leader’s speed, a band-passed crowd bed whose gain tracks race excitement, and a call-to-post bugle built from raw oscillator envelopes.</p><h3>The UX layer: tiers, consequences, and a reason to care</h3><p>The old game had one repeating race. Thunder Downs has a career:</p><ul><li>Four unlockable classes — Maiden ($0) → Metro Handicap ($2.5k) → Golden Cup ($6k) → Championship ($15k) — with bigger fields, bigger bet limits, and exotics gating. Unlocks key off your <em>peak</em> balance, so a bad streak never re-locks progress.</li><li>Race history and career stats persist in localStorage (old-version balances migrate automatically).</li><li>Go broke and a track sponsor offers a $500 bailout — the game is a sandbox, not a punishment.</li><li>Photo finishes get a freeze overlay before the stewards announce the result:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pz1loz8quDrx3Xt7.png" /></figure><p>Note the margins: “by 1 length”, finish times in the high 80s for 1200m on Heavy going — the going actually slowed the race, and the margin labels (nose, short head, neck, ¾ length...) come straight from real racing vernacular, mapped from time gaps at ~16.2 m/s.</p><h3>The mobile pass (and the bug hunt that came with it)</h3><p>A second session focused purely on making it feel native on iPhone:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/786/0*F3IxBh7s4AqHrbLH.png" /></figure><p>The interesting part wasn’t the features — it was the debugging loop. Fable 5 drove headless Chrome over the DevTools Protocol with a hand-rolled ~100-line Node script (no Puppeteer — the repo’s no-dependency rule applied to tooling too): navigate, click through a real bet, run a full race, assert on the DOM, screenshot every stage, capture every console error.</p><p>That harness caught two classics:</p><ol><li>The invisible expander. Race-card detail panels used hidden attributes… which were silently defeated by .rc-expand { display: grid }, because author styles beat the UA stylesheet&#39;s [hidden] { display: none }. Every panel rendered permanently open. One line fixes it: .rc-expand[hidden] { display: none; }.</li><li>The 46-pixel mystery. The iPhone viewport scrolled horizontally by 46px. The culprit — found by scripting a sweep over every element’s getBoundingClientRect() — was the CSS Grid blowout: grid items default to min-width: auto, so a single wide child forced the whole 1fr column past the viewport. The canonical fix: .panels &gt; * { min-width: 0; }.</li></ol><p>Plus the iOS-specific checklist: 16px inputs so Safari doesn’t zoom on focus, inputmode=&quot;numeric&quot; for the keypad, env(safe-area-inset-*) for the notch, dvh units for the URL-bar dance, touch-action: manipulation, 44px touch targets under @media (pointer: coarse), and a sticky bottom bet bar so you can back a horse and start the race without ever scrolling to the slip.</p><p>Final verification, all automated: no horizontal overflow in portrait or landscape, bet → race → settlement → next race green, zero uncaught exceptions.</p><h3>By the numbers</h3><p>BeforeAfterFiles3 (HTML/CSS/JS)6, logic isolated &amp; unit-testableOddsMath.random()softmax ratings + 16% overround, sim-calibratedFavorite EV~+40% (broken)−13% (house edge, like real life)Race sim1 loop, random walkphases, energy, lanes, slipstream, trafficGraphicsemoji + hue-rotateprocedural canvas, follow camera, particlesTrack on mobilehorses fly off-screenparametric geometry, resolution-independentSoundnonefully synthesized WebAudioBet typesWin/Place/Show (flat)+ Exacta, Quinella (Harville-priced)Progressionnone4 classes, history, career statsDependenciesGoogle Fonts + Font Awesome CDNszeroTestingnoneNode statistical suite + CDP end-to-end</p><p><strong>Edited — Added zh-hk support</strong></p><p>New file horses/js/i18n.js — a small i18n module loaded before the other scripts. It holds the full EN/zh-HK string dictionaries, auto-detects zh* browsers on first visit, persists<br> the choice to localStorage, and dispatches a langchange event that the game listens to, so switching language re-renders everything live — no page reload, even mid-session.<br> <br> Language toggle — a 中/EN button in the top bar next to the sound toggle (44px tap target on mobile).</p><p>HKJC-style terminology throughout:<br> — Bet types: 獨贏 (Win), 位置(頭2)/位置(頭3) (Place/Show), 連贏 (Quinella), 二重彩 (Exacta)<br> — Going scale: 快地 / 好地 / 黏地 / 軟地 / 大爛地, shown as 場地：好地<br> — Race card = 排位表, race classes 新馬 / 讓賽 / 盃賽 / 錦標, photo finish = 相片裁決<br> — Official margin terms: 鼻位, 短頭位, 頭位, 頸位, ¾馬位, N馬位, 大距離<br> — Wallet: 結餘 / 累計盈虧; slip: 總注碼 / 最高派彩</p><p>HK flavour beyond straight translation:<br> — All 45 horses got HKJC-style Chinese names (max 4 characters, like real HK racehorses): Quick Silver → 水銀瀉地, Lucky Charm → 福星高照, Jade Emperor → 玉皇大帝, High Voltage →<br> 電力十足…<br> — Jockeys got HK-press transliterations: Santos → 山度士, Andersson → 安達臣, Jackson → 積遜<br> — Race commentary written in HK racecall style: 「閘門大開！」「#3 追風逐電 搶先帶出！」「轉入直路！最後衝刺開始！」「XX 與 YY 鬥得難分難解！」<br> — Governor’s Plate became 督憲盃, and the canvas tote board also switches to 雷霆馬場</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g66bAaT_CjxX3TOZ4cfEtw.png" /></figure><h3>Takeaways</h3><ol><li>Make the core logic headless. The single biggest enabler was engine.js running in Node. &quot;Do favorites win as often as the odds say?&quot; became a 5-second script instead of an afternoon of manual playtesting.</li><li>Calibrate, don’t vibe. Every gameplay-feel change (margins, longshots, fades) was validated against hundreds of simulated races before shipping. The AI didn’t just write the feature — it wrote the experiment that proved the feature.</li><li>Constraints are a feature. No build step and no dependencies forced procedural art, synthesized audio, and a raw-CDP test harness — and the result is a single folder of static files that will run unchanged for a decade on GitHub Pages.</li><li>The browser is a fantastic game console — if you respect min-width: 0.</li></ol><p><em>Built with Claude Fable 5 in Claude Code. The whole thing — review, plan, engine, renderer, audio, UI, calibration, mobile pass, and automated verification — happened in two conversational sessions.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=04b3db724af2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built an AI Companion That Lives Entirely on My Home Network — Chat, Photos, and Video, Zero…]]></title>
            <link>https://vxrl.medium.com/i-built-an-ai-companion-that-lives-entirely-on-my-home-network-chat-photos-and-video-zero-934e96259728?source=rss-ac8a64f61467------2</link>
            <guid isPermaLink="false">https://medium.com/p/934e96259728</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ollama]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-companion]]></category>
            <dc:creator><![CDATA[VXRL]]></dc:creator>
            <pubDate>Sun, 14 Jun 2026 13:56:37 GMT</pubDate>
            <atom:updated>2026-06-14T13:56:37.587Z</atom:updated>
            <content:encoded><![CDATA[<h3>I Built an AI Companion That Lives Entirely on My Home Network — Chat, Photos, and Video, Zero Cloud</h3><p>Researcher: {alanh0}</p><p><em>A local-first, mobile-first AI companion that chats in Cantonese or English, sends AI-generated selfies mid-conversation, shoots short video clips, and reads photos you send it — without a single byte leaving your LAN.</em></p><p>Most “AI companion” apps are thin wrappers around someone else’s cloud. Every message and selfie ships to a server you don’t control. I wanted the opposite: a companion that runs entirely on hardware I own, yet still feels alive — natural texting, photos it “takes” of itself, and short videos.</p><p>It’s called My Companion. Single origin (:18888), mobile-first so it feels like WhatsApp, and the only things it talks to are an Ollama server (the language brain) and a ComfyUI server (the image/video studio) on the same network.</p><h3>The cast</h3><p>Open it and you get a general-purpose Assistant (a local ChatGPT that can also draw and animate), plus any companions you build yourself — each a persona with its own personality and AI-generated face. A companion can be any gender or relationship: a girlfriend, a boyfriend, a bro, a buddy, a mentor — whoever you want.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*OvFBUQRcBYpUKqg3BGGfmA.png" /></figure><p>Here I’ve built <strong>Mary</strong> — a 25-year-old Hong Kong PE teacher who texts in Cantonese and lives for football. Building one is quick: fill a couple of fields, tap ✨ Auto-describe and the LLM writes the visual description, then Generate profile picture turns it into an avatar (or upload your own).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*DcvcQuBkyUCLkBMkOTjwzw.png" /></figure><h3>1. It talks like a person, not a chatbot</h3><p>Mary replies in Hong Kong Cantonese — real colloquial Traditional Chinese (係/喺/嘅/咗/啦), not stiff textbook Mandarin.</p><p>She also has agency: she teases, pushes back, disagrees, and won’t validate everything just to please you. And she won’t bluff — ask about a result she hasn’t seen and she says so rather than inventing a scoreline.</p><p>She remembers, too. A background memory quietly builds across the relationship — genuinely specific lines like <em>“Mary uses Now TV… for exclusive sports coverage”</em> and <em>“Mary plays football after school as a stress-relief activity.”</em> Nothing hard-coded; it’s distilled from the chat and fed back as quiet context.</p><p>And for anything genuinely <em>current</em> — a fixture, last night’s score — she doesn’t guess. The app fires a single lookup at a self-hosted SearXNG box and folds the real results in. It’s the one optional path that touches the open web; turn it off and everything stays on the LAN.</p><p>You can watch it work. I ask Mary who Germany plays tonight; she guesses <em>Ecuador, 9pm</em>. I push back — <em>“check properly”</em> (你check真啲?) — she runs the lookup and corrects herself: Germany vs Curaçao, 6pm. Asked where Curaçao is, she nails it too — <em>a Caribbean island north of Venezuela</em>. Real facts, woven in. No links, no “I searched.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*xtaGKWUxXxMckJphb156lw.png" /></figure><h3>2. It sends photos — that look like the character</h3><p>Mid-conversation, a companion can take and send a photo. Ask Mary, in Cantonese, to show where she trains and she sends a candid shot from her pitch — then, asked for a food pic, one of her noodles:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/674/1*Vmh7cs4X8YAJg-C3m8T7pQ.png" /></figure><p>The text and the photo always agree, because one hidden instruction drives both. And the face stays consistent shot to shot via a fixed identity anchor plus an optional PuLID face-reference; without it, a long “beach in a suit” prompt would drift to a different look entirely. Photos default to a casual phone-snapshot look — candid, grainy, unposed — not a studio shoot, unless you ask.</p><h3>3. …and it shoots video</h3><p>Ask for a <em>video</em> and you get a short clip from Wan 2.2. If the companion is in it, the app first renders a still of them (so they look like themselves), then animates it; a person-free scene goes straight text-to-video.</p><p>The clip below is shown as a GIF so it embeds in this post — in the app it’s a real ~7-second MP4 that plays inline, rendered locally on an ASUS GX10, no cloud. Ask Mary for a clip of her eating ramen and she sends one, the same face from her photos, animated:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*rZW4hQPnGfdiK0epBokuUA.gif" /></figure><h3>4. The Assistant: a local creative tool</h3><p>The Assistant is the same engine minus the persona. It chats, generates images and videos from a plain request, reads images you upload, and — my favourite — edits an image you send it.</p><p>I pasted in a cartoon Goku and asked it to <em>“make this anime character a real person”</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*gjU8AutaSBQhsHZD6G0udQ.png" /></figure><p>A vision model reads the upload, the app runs an image-to-image transform, and out comes a photoreal version — then I asked for a <em>video of him eating ramen</em> and it animated that:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*a3yA9mgvM6Vw9RtcNCvk3A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*psG5VViDJ-Y5RrcVDiYSuQ.gif" /></figure><p>You type plain words; the app does the prompt-writing. No literal image prompts, no parameters.</p><h3>Under the hood: it’s all orchestration</h3><p>The honest lesson of this project: no single local model does all of this. Even the hosted giants route video to a separate model. So the app is an orchestrator — a FastAPI backend conducting one specialist per lane:</p><pre>React SPA (mobile)<br>   │  served by FastAPI, one origin :18888<br>   ▼<br>FastAPI  —  the orchestrator<br>   │<br>   ├──► Ollama    chat LLM (Cantonese / English)<br>   │              + a vision model that reads images<br>   │<br>   ├──► ComfyUI   Flux.2 — text→image, image→image,<br>   │              + PuLID same-face identity<br>   │              Wan 2.2 — image→video, text→video<br>   │<br>   └──► SearXNG   optional web grounding (1 outbound hop)</pre><p>A chat turn is a small server-side pipeline, streamed to the browser over Server-Sent Events:</p><ol><li>Assemble the context — persona, language rules, memory, and a “right now” sense of time and place, so she stays consistent turn to turn.</li><li>Stream the reply, and quietly decide if this turn also wants a photo or video.</li><li>Hand the visual to ComfyUI while the text reply is saved immediately — so a phone that sleeps mid-render still shows the reply and a placeholder, and the media lands on its own later.</li></ol><p>The real work is the glue between those steps — turning a casual message into the right generation and keeping a face recognisable across scenes.</p><h3>Why per-lane specialists win</h3><p>I tried to collapse the stack to one model. The unified “omni” models perceive everything and even stream speech, but their image quality trails dedicated Flux and video is barely usable. The rule held everywhere: a sharp specialist beats a do-everything generalist. The orchestrator is the product.</p><h3>The local-first payoff</h3><p>Everything runs on my LAN, so the trade-offs invert: latency is GPU-bound, not network-bound; there’s no per-message bill; and the conversations, faces, and memory are nobody’s training data but mine.</p><blockquote><em>A note on responsibility: this can render a real person’s likeness on demand. The obvious line applies — likeness and voice belong to real people, and impersonating someone without consent isn’t on. Local means control, not a free pass.</em></blockquote><h3>Limitations</h3><p>It’s not magic. One GPU is a serial bottleneck — a photo takes seconds-to-minutes, a clip longer, and you can’t render two heavy jobs at once. Face consistency is strong but not perfect; tricky poses or group shots can still drift. Video is the roughest lane: a clip is animated from a single rendered still, so the motion stays inside that photo’s scene — a short, gentle movement, not a new shot or location — and fine details (spiky hair, hands) can wobble or morph. The local chat model occasionally needs a nudge to send the right photo. The Cantonese still isn’t perfectly smooth — it’s good, but the odd phrase reads a touch off-tone or slips toward written Chinese. There’s no voice yet. And without SearXNG enabled, anything “current” is a guess — the lookup is what keeps it honest.</p><h3>Future plan</h3><p>Next is the sense it’s missing: a voice. Self-hosted, cloned-voice text-to-speech (Cantonese + English) and real-time voice conversion — same pattern, a new specialist behind the same conductor.</p><p>Because by now the lesson is clear: you don’t wait for one model to do everything. You build the orchestra.</p><p><em>Built on FastAPI + SQLite + a React/Vite/Tailwind SPA, with Ollama and ComfyUI as LAN services — all of it running on a single ASUS GX10 at home. Nothing leaves the house.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=934e96259728" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>