AI-Powered Reverse Engineering: A Complete Walkthrough of Cracking Sliding Puzzle CAPTCHAs

Introduction: Why Traditional Reverse Engineering Hits a Wall

Sliding puzzle CAPTCHAs have long been one of the toughest challenges for web scrapers and reverse engineers. In the traditional "old-school" reverse engineering workflow, engineers must manually analyze API endpoints, locate key parameters, reconstruct encryption algorithms, and then use a fixed set of rules to calculate sliding distances and movement trajectories.

The problem is — CAPTCHA rules keep changing. Cracking methods built on fixed algorithms and accumulated experience are gradually becoming obsolete. When target websites introduce mechanisms like WASM encryption, multi-layered environment detection, and trajectory template matching, the workload for traditional reverse engineering grows exponentially.

This article is based on a hands-on demonstration that compares the "old-school" approach with "AI-powered" reverse engineering for cracking sliding puzzle CAPTCHAs. We explore what AI reverse engineering actually changes — and whether it can truly replace traditional reverse engineers.

The Core Challenges of Sliding Puzzle CAPTCHAs

The target in this demo isn't your typical "drag-to-fill-the-gap" CAPTCHA. Instead, it's a sliding puzzle restoration challenge: the image is displayed in a scrambled state, and the user must drag a slider to align two shuffled and reassembled images on top of each other. Only when they're correctly overlapped and the mouse is released does the verification pass.

Analysis with a packet capture tool reveals that the verification endpoint carries encrypted parameters. The call stack appears deceptively simple — only five levels deep — but clicking into it reveals the entire codebase is heavily obfuscated.

To make things even more difficult, the site's core encryption logic is implemented in a WASM file. AI analysis determined this WASM was written in Go and compiled from source. Engineers have two options: invoke the WASM file via the JS side (which requires patching a large amount of environment code, since the site's environment detection is extremely strict), or directly "extract the algorithm" — pulling out the encryption logic to run independently, bypassing the need to patch the environment.

Following a complete old-school reverse engineering workflow, an engineer would need to: trace through the WASM implementation stack, patch environment detection, reconstruct the image scrambling algorithm, write an image-matching and positioning algorithm... every step done by hand, representing an enormous amount of work.

The AI Reverse Engineering Workflow: Starting From a Single URL

In sharp contrast to the tedious traditional approach, the starting point for AI-powered reverse engineering is remarkably simple — just give the AI a link.

In the demonstration, the author used a GPT-5 model combined with JS Reverse-related Skills and MCP tools, directing the AI to operate a browser with a special fingerprint (a Chrome browser with a GROK fingerprint) to access the target page. A standard Chrome browser wasn't used because the CAPTCHA simply failed to load in a local environment — likely due to a blocked fingerprint.

One notable detail: throughout the entire session, the author never manually specified a single Skill. The AI automatically matched Skills from its index based on the prompt, loaded the appropriate Skill, and executed the workflow. After the author manually completed one successful verification, they issued a single instruction to the AI: "Save the protocol locally, implement the code file, and create it at the specified path." The AI then began its autonomous analysis.

The fundamental shift here is that AI no longer requires engineers to hard-code every rule in advance. Instead, it uses visual understanding, reasoning, and autonomous learning to complete the task. It can independently determine whether the current page uses a new or old version of the WASM file, and saves the original assets along with successful round requests as a reference.

Image Reconstruction Algorithm: Algorithm First, OCR as a Fallback

For the image reconstruction step, the author emphasized an important engineering principle: use an algorithm whenever possible — don't reach for OCR.

Why? Because OCR models are cumbersome to train, large in size, slow to start up, and relatively inefficient at recognition — the overall cost is high. OCR should serve as a "last resort" — only when it's genuinely impossible to write a recognition algorithm should you fall back to it.

This demo uses a traditional computer vision positioning algorithm rather than a deep learning model. The core logic is:

• Calculate the position of the splice line from the original and displayed images (e.g., coordinate 202)
• Scale to page dimensions and iterate over horizontal offsets
• For each candidate offset, sample a strip region of approximately 12px at the splice line
• Compare whether the top and bottom image sections are continuous at that offset
• Use methods like NMI to remove adjacent duplicate peaks and perform boundary anchor calibration

In simple terms: iterate point by point, matching top and bottom, until a continuously aligned position is found. Some may worry whether a 12px strip is stable enough or whether the deviation is too large — in practice, the algorithm continuously performs fine-tuning (micro-adjustments) internally to ensure accuracy. The advantage of this pure algorithmic approach is speed and zero startup overhead, making it far more efficient than OCR.

Trajectory Template Matching: A Hurdle Even AI Can't Skip

Even the most perfectly written recognition algorithm cannot guarantee a 100% pass rate — after all, even human operators can't achieve that.

This site clearly combines multiple layers of protection:

• Verification timeout: If the CAPTCHA is left open too long without sliding, even a successful slide will fail due to timeout (similar to ByteDance's Doudian rotation verification)
• Trajectory template matching: Reusing a single trajectory template too many times results in direct rejection — a mechanism also common in Alibaba's verification systems
• Environment detection and fingerprint validation: Virtually every mainstream protection technique is in play

In practice, the AI completed the full workflow, but the first verification attempt failed — and the culprit was exactly the trajectory issue. The author's solution was to have the AI reference a set of manually filtered trajectory templates that had previously passed server-side verification nine times.

This reveals a key insight: even with AI-powered reverse engineering, human-provided real movement trajectories are still required. Engineers need to use MCP to hook or capture packets, collecting multiple rounds of real human sliding and clicking data to use as templates. Only then does the behavior appear authentic enough to pass verification.

Results and the Benchmark for Success

After several rounds of debugging, the AI progressively resolved issues like "ambiguous locators" and missing command-line parameters. Results were inconsistent — sometimes returning a 200 OK but still failing verification, indicating the pass rate was still low.

However, the author offered an important benchmark: as long as verification succeeds even once, it proves there's nothing fundamentally wrong with the code logic or the overall approach. Any remaining failures can only stem from three causes: inaccurate recognition algorithm, insufficiently realistic trajectory templates, or external factors like IP blocking. From that point on, improving the pass rate is purely a matter of continuously refining the recognition algorithm and trajectory templates.

Conclusion: What Has AI Reverse Engineering Actually Changed?

Back to the original question — when AI can already autonomously perform CAPTCHA analysis and reverse engineering inference, is there still work for traditional reverse engineers?

Based on this demonstration, the answer is yes — but the role has shifted. AI-powered reverse engineering dramatically compresses the repetitive work of analysis, environment patching, and algorithm writing, freeing engineers from tedious manual labor. But AI is far from omnipotent:

1. High-difficulty targets still require human course correction — AI can easily go off track
2. Real trajectory data still depends on human collection — something machines can't fabricate from scratch
3. Pass rate optimization remains an ongoing engineering effort — requiring continuous refinement of algorithms and strategies

So perhaps a more accurate framing is this: AI reverse engineering doesn't replace engineers — it shifts them from manual labor to strategic work. Reverse engineers who master AI toolchains will far outperform peers who rely solely on old-school methods. That is the true meaning of "AI reverse engineering is the way forward."