Tor .onion Captcha Solver

The target site uses a broken-circle captcha served as an <input type="image" name="cap_response"> form element.

How it works:

• A photograph (random image — cats, people, Christmas scenes, etc.) is displayed
• Multiple colored circle outlines are overlaid on the photo (8–15 circles per captcha)
• Most circles are complete (full ring, like the letter O)
• Exactly one circle has a visible gap in its outline (like the letter C)
• The user must click the center of the broken circle
• The <input type="image"> submits the (x, y) click coordinates relative to the image's natural dimensions
• The server validates the coordinates — if wrong, it returns "Invalid response"

Timing:

• Initial page load → 12–15s meta-refresh redirect (anti-bot delay)
• Captcha page appears → 60-second solve window
• On success → "Captcha solved" intermediate page → 30s wait → final redirect to marketplace

Key HTML structure:

<form method="post" action="/captcha">
  <input name="cap_response" type="image" src="/captcha_image.png">
</form>

Deploy command:

scp tor-proxy/index.ts root@178.156.250.12:/opt/tor-renderer/index.ts
ssh root@178.156.250.12 'pkill -9 bun; sleep 2; systemctl restart tor-renderer'

Test command:

curl -X POST http://localhost:3002/render \
  -H "Content-Type: application/json" \
  -H "X-API-Key: <key>" \
  -d '{"url": "http://<onion>.onion", "timeout": 180000}'

Phase 1: Algorithmic Pixel Analysis (0 cost, instant)
  ↓ fails →
Phase 2: Element-Targeted AI Vision (Gemini, pixel coords)
  ↓ fails →
Phase 3: Full-Screenshot AI Vision (Gemini, normalized 0-999 coords)
  ↓ fails →
All phases exhausted — captcha not solved

Phase 1: Algorithmic Pixel Analysis

How it works:

• Screenshots the #cap_response element directly (not the full page)
• Opens an isolated Playwright browser context with JS enabled
• Renders the screenshot into a <canvas> element
• Scans for saturated colored pixels (S > 35%, L between 25–80%)
• Clusters pixels by hue + spatial proximity
• Fits circles via bounding box, samples circumference in 72 sectors (5° each)
• Identifies the circle with the largest consecutive gap in sector coverage
• Returns the center coordinates of that circle

Current reliability: ~20% — the photo background produces false colored-pixel clusters that confuse the gap detection.

Phase 2: Element-Targeted AI Vision

How it works:

• Screenshots just the #cap_response element
• Sends to Gemini with prompt asking for pixel coordinates relative to the element image
• Prompt includes the element dimensions (e.g., "bottom-right is 420,420")
• Uses maxOutputTokens: 64 to force terse responses
• Clicks at the element-relative position via box.x + clickX, box.y + clickY

Current reliability: ~30% — Gemini sometimes returns empty responses, possibly due to RLHF safety filters on the image content.

Phase 3: Full-Screenshot AI Vision (THE WINNER)

How it works:

• Screenshots the #cap_response element
• Sends to Gemini with prompt asking for normalized 0–999 coordinates
• Converts: clickX = (x / 1000) * box.width, clickY = (y / 1000) * box.height
• Clicks at absolute viewport position: box.x + clickX, box.y + clickY
• Uses maxOutputTokens: 512 (needs more room for the normalized format)

Current reliability: ~60–70% — this is what achieved the first successful bypass.

Converting normalized → element pixels → viewport absolute:

const clickX = Math.round((normalized_x / 1000) * box.width);
const clickY = Math.round((normalized_y / 1000) * box.height);
const absX = box.x + clickX;    // viewport-absolute X
const absY = box.y + clickY;    // viewport-absolute Y

Every captcha attempt saves the element screenshot to /tmp/ on the server:

const fs = require('fs');
fs.writeFileSync(`/tmp/captcha_debug_${Date.now()}.png`, screenshotBuffer);

To download and inspect:

scp root@178.156.250.12:/tmp/captcha_debug_*.png ./

TIP: Always visually inspect the debug images when the algorithm is wrong. Without seeing the captcha, you're flying blind — ~8 iterations were wasted before adding this.

• Always log parse errors. An empty catch {} silently swallowed weeks of valid Gemini responses.
• Screenshot the element, not the page. This eliminates all coordinate mapping headaches.
• Treat navigation as success. In captcha-solving, if the page navigates after your click, you probably won.
• Debug images are mandatory. Adding /tmp/captcha_debug_*.png saving was the single most impactful change.
• LLM vision APIs need room to breathe. maxOutputTokens: 128 + a model that loves preamble = truncated JSON. Default to 512+.
• The algorithmic approach has a ceiling. Heuristic pixel analysis works for simple cases but struggles with photographic backgrounds. AI vision is more reliable for this captcha type.
• Anti-bot detection is subtle. Even after getting the right coordinates, instantaneous mouse movement can fail silently. Human-like movement (45-step bezier, random delays) was necessary.

• [ ] Retry loop at the top level — if Phase 1 fails, reload the page for a fresh captcha before trying Phase 2/3
• [ ] Use Gemini Pro instead of Flash for harder captchas — may have better spatial reasoning
• [ ] Local CV with Sharp/OpenCV — detect circle contours directly without sending images to an API (faster, no safety filter risk)
• [ ] Rate limiting awareness — the captcha server may rate-limit after too many wrong clicks from the same Tor circuit

Symptom

The captured HTML rendered as raw, unstyled text — no colors, no layout, no sidebar.

Root Cause

The .onion page references an external stylesheet:

<link href="/static/style.css" rel="stylesheet">

Our renderer captured the raw HTML but didn't fetch or inline the CSS. The non-onion path had CSS inlining via page.evaluate() + fetch(), but that requires JavaScript — which was disabled for .onion pages.

Failed Attempt

We tried creating a new browser context with javaScriptEnabled: true to fetch the CSS, but that context didn't have the Tor SOCKS5 proxy configured, so it couldn't reach the .onion server.

Working Fix

Open a new page in the SAME browser context (which shares the Tor SOCKS5 proxy), navigate to each stylesheet URL, and capture the response text:

const linkMatches = [...rawHtml.matchAll(/<link[^>]*href="([^"]*)"[^>]*rel="stylesheet"/gi)];

const cssPage = await page.context().newPage();

for (const match of linkMatches) {
  const href = match[1];
  const cssUrl = baseOrigin + href;
  const cssResponse = await cssPage.goto(cssUrl, { timeout: 30000, waitUntil: 'commit' });
  if (cssResponse?.ok()) {
    const cssText = await cssResponse.text();
    fetchedCSS.push({ href, cssText });
  }
}
await cssPage.close();

// Replace <link> tags with inline <style> blocks
for (const { href, cssText } of fetchedCSS) {
  html = html.replace(
    new RegExp(`<link[^>]*href=["']${escapeRegex(href)}["'][^>]*>`, 'gi'),
    `<style>/* Inlined from ${href} */\n${cssText}\n</style>`
  );
}

Symptom

A dark modal overlay covered the entire page with "News and announcements" content.

Root Cause

The popup uses a CSS-only checkbox toggle (no JavaScript required):

<style>
  #checkbox_show_announcements:checked ~ #modal_show_announcements {
    display: block;
  }
</style>
<input type="checkbox" id="checkbox_show_announcements" checked="">
<div class="modal" id="modal_show_announcements">...</div>

Working Fix

Strip the checked attribute from the HTML using regex, and add a CSS safety net:

html = html.replace(
  /(<input[^>]*id="checkbox_show_announcements"[^>]*)checked="[^"]*"/gi, '$1'
);
html = html.replace(
  /(<input[^>]*id="checkbox_show_announcements"[^>]*)checked\b/gi, '$1'
);
html = html.replace('</head>',
  '<style>#modal_show_announcements{display:none!important}</style></head>'
);

Symptom

The captcha solved successfully but the renderer captured the "Please Wait" intermediate page instead of the final marketplace.

Root Cause

After the captcha is solved: Captcha → [click] → "Please Wait" (30s) → "Drug Hub - Listings". The solver checked isSolved by verifying the title no longer contained "captcha" — which was true for "Please Wait" — but didn't wait for the final redirect.

Fix

const needsRedirect =
  t.toLowerCase().includes('please wait') ||
  t.toLowerCase().includes('wait') ||
  bodyText.includes('Captcha solved') ||
  bodyText.includes('connect you to the backend') ||
  bodyText.includes('Please wait');

if (needsRedirect) {
  console.log('[CAPTCHA] On intermediate page — waiting up to 120s...');
  try {
    await page.waitForNavigation({ timeout: 120000 });
  } catch (e) {
    console.log('[CAPTCHA] Redirect wait ended');
  }
  await page.waitForTimeout(3000);
}

Applied to all three solver phases.

Symptom

When viewing the captured HTML in a JS-enabled iframe, a "Warning! JavaScript is enabled" overlay appeared.

Root Cause

The .onion site includes a .js-modal div that displays when JavaScript is active — a security warning to users. The viewer renders in a JS-enabled iframe, triggering this.

Fix

html = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');
html = html.replace(
  /<div[^>]*class="[^"]*js-modal[^"]*"[^>]*>[\s\S]*?<\/div>\s*<\/div>\s*<\/div>\s*<\/div>/gi, ''
);
html = html.replace('</head>', '<style>.js-modal{display:none!important}</style></head>');

Captcha Solved
  ↓
Wait for "Please Wait" → final redirect (up to 120s)
  ↓
Fetch /static/style.css via new page in same Tor-proxied browser
  ↓
Capture page.content() as raw HTML
  ↓
Inline CSS: replace <link> with <style> blocks
  ↓
Strip popup: remove 'checked' from announcements checkbox
  ↓
Strip scripts: remove all <script> tags
  ↓
Strip .js-modal: remove JS-detection overlay
  ↓
Add safety-net CSS: force-hide modals
  ↓
Return clean, styled HTML

The Black Ops marketplace uses a fundamentally different captcha than DrugHub. Both parts are submitted as a single `<form method="post">`:

Part 1: Mirror URL Text Challenge (algorithmic)

• A dark banner image shows "Mirror:" followed by the site's .onion URL
• Some characters in the URL are replaced by asterisks (*)
• User types the missing characters only into <input name="code" type="text">
• Example: If mirror shows http://blackop**3zlg... and actual URL has blackops3zlg..., answer is s3

Part 2: Odd-One-Out Image Click (vision)

• A grid of 3D-rendered objects/icons/shapes on a dark background
• Most objects look identical; exactly one is visually different
• User clicks the different one via <input name="figure" type="image">
• Form submits code=CHARS&figure.x=X&figure.y=Y

Key HTML structure:

<form method="post">
  <input name="code" type="text" placeholder="Enter missing characters...">
  <div class="img-container">
    <input name="figure" type="image" src="data:image/png;base64,...">
  </div>
</form>

Timing:

• Initial page load → 12s meta-refresh redirect
• Captcha page (title: "Captcha - Black Ops")
• On success → Title changes to onion domain → marketplace content loads

Before running any solver, the system detects which captcha type is present:

type CaptchaType = 'broken_circle' | 'blackops_mirror' | 'altcha_pow' | 'simple_checkbox' | 'generic_vision' | 'none';

async function detectCaptchaType(page: Page): Promise<CaptchaType> {
  const html = await page.content();
  if (html.includes('name="code"') && html.includes('name="figure"')) return 'blackops_mirror';
  if (html.includes('name="cap_response"') || html.includes('id="cap_response"')) return 'broken_circle';
  if (html.includes('altcha-widget') || html.includes('altcha')) return 'altcha_pow';
  // ...
}

Step 1: OCR Mirror URL + Extract Missing Characters (Gemini)

The mirror URL text is rendered inside an image (not as HTML text). Gemini reads it.

Prompt strategy:

This captcha shows a dark banner with "Mirror:" followed by a URL.
Some characters are replaced by asterisks (*).

The actual URL is: http://blackops3zlgfuq4dg4yrtxoe57u3sxfa34kqzbooqbovutleqhf3zqd.onion

Reply with ONLY two lines:
Line 1: The missing characters concatenated together
Line 2: The full mirror URL with asterisks

Key insight: Providing the actual URL in the prompt lets Gemini do the comparison directly.

Step 2: String Diff Cross-Check (algorithmic)

if (mirrorUrl.includes('*')) {
  let diffChars = '';
  for (let i = 0; i < mirrorUrl.length && i < actualUrl.length; i++) {
    if (mirrorUrl[i] === '*') diffChars += actualUrl[i];
  }
  missingChars = diffChars;  // deterministic — prefer over Gemini's extraction
}

This was the breakthrough — the string diff is deterministic and reliable, even when Gemini truncates the URL.

Step 3: Detect Odd-One-Out Figure (Gemini Vision)

This image shows a grid of 3D objects. All look similar except ONE that is different.
Return ONLY: {"x": NUMBER, "y": NUMBER}

maxOutputTokens: 512 (same lesson as Bug 2).

Step 4: Submit Form

await page.locator('input[name="code"]').fill(missingChars);

const clampedX = Math.max(1, Math.min(figureX, figBox.width - 1));
const clampedY = Math.max(1, Math.min(figureY, figBox.height - 1));

await Promise.all([
  page.waitForNavigation({ timeout: 30000 }).catch(() => {}),
  figureEl.click({ position: { x: clampedX, y: clampedY }, delay: 80 }),
]);

• Ask for the answer FIRST, the evidence SECOND. When Gemini truncates, you get the critical data.
• Provide context you already know. Giving Gemini the actual URL lets it compare directly.
• Deterministic string diff > AI extraction. Even partial OCR is useful with a known reference string.
• `element.click()` ≠ `mouse.click()` for form submission. <input type="image"> requires element-originated click.
• Same `maxOutputTokens: 512` that solved DrugHub also solved Black Ops. Proven configuration transfers.

AWazon uses the same broken-circle captcha as DrugHub, but the captcha image is rendered without any discoverable HTML element.

DrugHub (worked):

<input name="cap_response" type="image" src="/captcha_image.png">

AWazon:

Captcha page title: "AWazon Market - DDOS Protection". Text says "Click the broken circle (the one with a cut)" — but findCaptchaImageLocator() returns null for all known selectors (#cap_response, input[type="image"], img[src*="captcha"], canvas, generic img).

Pre-captcha flow:

• Initial page load → "Access Queue" with spinner
• 12–15s meta-refresh redirect to captcha page
• Captcha page with ~60 second "Captcha Timeout" progress bar
• On success → redirects to marketplace login/register page

The entire 3-phase waterfall was built around finding a captcha HTML element. When no element existed:

• Don't assume an element exists. Build viewport-coordinate fallback from day one.
• Cache expensive lookups. A 21-second function called 5 times = 2 minutes wasted.
• `maxOutputTokens` bites twice. Default to 512+ for any vision call. No exceptions.
• Budget time across phases. 60s captcha timeout − 45s polling = impossible solve window.
• Frontend stop must actually stop. Patch DB + discard in-flight results.
• The algorithmic solver won. Phase 1 solved AWazon on first click — viewport-coords approach avoids all coordinate mapping complexity.

Captcha Format

The site uses a two-stage captcha architecture:

#### Stage 1: Entry Gate (drawcaptcha4.php)

• Large bold captcha characters (~6 hex chars like 714d1b) in center of image
• Noisy background with .onion URL at top and mirror domain names at bottom
• Input: placeholder="What's the captcha? - lowercase only"
• Anti-phishing: 9 forms total — 3 honeypots (name="fuckno", name="phishersucks", class="phishersucks"), only 1 visible real form with a random hex name attribute

#### Stage 2: Login Page (jcaptcha.php)

• Not solved — requires credentials; entry gate bypass is sufficient

Anti-Phishing Defense

Detection strategy: page.evaluate() with getComputedStyle() + offsetParent to filter visible forms, then exclude known honeypot names.

Key Bugs Fixed

Success Rate (WeTheNorth)

Multi-Stage Flow

1. Initial page load → meta-refresh redirect (~5s)
2. "Omega Market | Protection Layer" queue page (JS countdown ~10-15s)
3. "DDOS Protection" captcha page (6-char sequential captcha)
4. Submit → if correct → back to "Protection Layer" (success intermediate)
5. Auto-redirect → marketplace

Captcha Format

• 6 input boxes: name="c1" through name="c6", maxlength="1", pattern="[A-Za-z0-9]"
• Circular image (~120–170px): photograph with a single distorted white character overlaid
• Image swapping: Clicking each input box changes the circle image via JS — shows that box's character
• Submit: <button class="before" type="submit">Submit</button>
• Timer: ~60s countdown

Critical Architecture Decision: JavaScript Required

Unlike all other .onion captchas solved (which work with JS disabled), Omega's captcha requires JavaScript for the image-swapping behaviour. Each input box triggers a JS handler that swaps the src of the circle image.

Solution: Create a separate browser context with javaScriptEnabled: true, navigate to the URL fresh, wait for the queue countdown, then solve in the JS-enabled context.

Solver Implementation

Type: omega_char
Model: gemini-flash
maxOutputTokens: 512
Temperature: 0.1 (deterministic reads)
Sequential: Focus each input → screenshot circle → OCR → type → repeat × 6

Success detection: Post-submit title changes from "DDOS Protection" to "Omega Market | Protection Layer" (success intermediate), then auto-redirects.

Queue Page Handling

• Poll every 5s for up to 90s
• Check for name="c1" + name="c6" inputs to confirm captcha loaded
• Handle page.content() errors during navigation (page changing while checking)
• Fall back after timeout

Key Bugs Fixed

Success Rate (Omega)

These rules have now been validated across 4 sites and 28 bugs. Apply them before touching a new captcha: