Skip to main content
Vulnerability Database/CVE-2026-100187

CVE-2026-100187: AIL Framework Onion Module SSRF Vulnerability

CVE-2026-100187 is an SSRF flaw in AIL Framework's Onion module that allows attackers to inject arbitrary targets into the crawler queue through crafted URLs. This article covers technical details, exploitation risks, and mitigation.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-100187 Overview

CVE-2026-100187 affects the Onion module in the AIL (Analysis Information Leak) Framework, an open-source threat intelligence platform. The module's URL extraction logic contained a performance shortcut that classified any 69-character string ending in .onion as a valid onion domain. This bypass skipped proper hostname parsing and onion-domain validation. An unauthenticated attacker who could publish content crawled by the framework could inject non-onion URLs, including IP addresses and arbitrary hostnames, into the crawler's task queue. The flaw maps to [CWE-20: Improper Input Validation].

Critical Impact

Unauthenticated attackers can redirect the AIL crawler toward arbitrary network resources by crafting URLs that satisfy a naive length-and-suffix check, compromising the integrity of crawler target selection.

Affected Products

  • AIL Framework (Onion module, bin/modules/Onion.py) prior to commit 5c8a68b
  • Deployments ingesting untrusted or publicly sourced content
  • Analyst workflows depending on onion-only crawling scope

Discovery Timeline

  • 2026-09-25 - CVE-2026-100187 published to the National Vulnerability Database
  • 2026-09-25 - Last updated in NVD database

Technical Details for CVE-2026-100187

Vulnerability Analysis

The Onion module scans crawled content for strings that resemble .onion URLs and queues matching domains for further crawling. To accelerate parsing, the module included a conditional branch that short-circuited validation when a candidate URL was exactly 69 characters long and ended with .onion. In that branch, the code sliced the domain directly from the string using a fixed offset (url[7:]) instead of invoking the proper hostname extraction helper. No parsing of the authority component took place, and no cryptographic structure check against v3 onion address format occurred.

As a result, strings such as http://1.2.3.4:8080/path/attacker-controlled-payload.onion could satisfy the length and suffix constraints while pointing at non-Tor infrastructure. The crawler would then dispatch requests to attacker-chosen destinations under the assumption that they were legitimate hidden services.

Root Cause

The root cause is improper input validation in a performance-optimized code path. The shortcut relied on two superficial properties — total length and trailing substring — rather than invoking crawlers.get_url_domain() and crawlers.is_valid_onion_domain() for every candidate.

Attack Vector

Exploitation requires no authentication and no user interaction. An attacker publishes crafted content on any resource the framework crawls, embedding a URL that meets the 69-character length requirement and terminates in .onion. When the Onion module processes the content, the malicious URL is accepted and queued, directing crawler traffic to the attacker's chosen target.

python
            # TODO Crawl subdomain
            if len(url) >= 62:
-                # perf
-                if len(url) == 69 and url.endswith(".onion"):
-                    domain = url[7:]
+                domain = crawlers.get_url_domain(url)
+                if domain and crawlers.is_valid_onion_domain(domain):
                    domains.add(domain)
                    onion_urls.append(url)
-                else:
-                    domain = crawlers.get_url_domain(url)
-                    if domain:
-                        if crawlers.is_valid_onion_domain(domain):
-                            domains.add(domain)
-                            onion_urls.append(url)

Source: GitHub Commit 5c8a68b — the patch removes the length-based shortcut and routes every candidate through full domain parsing and onion validation.

Detection Methods for CVE-2026-100187

Indicators of Compromise

  • Entries in the Onion crawler task queue whose domain field does not match the v3 onion address format (56 base32 characters followed by .onion).
  • Outbound crawler requests from AIL hosts to public IP addresses or clearnet hostnames rather than Tor SOCKS endpoints.
  • Crawled items containing 69-character strings ending in .onion where the leading characters form an IP or non-onion authority.

Detection Strategies

  • Review historical crawler job logs for queued domains that fail v3 onion validation after the fact.
  • Correlate AIL process network telemetry with the configured Tor proxy; direct egress to non-Tor destinations warrants investigation.
  • Inspect ingested paste and web-crawl artifacts for crafted strings matching the length-plus-suffix pattern.

Monitoring Recommendations

  • Alert on AIL worker processes initiating connections outside the Tor SOCKS proxy IP and port.
  • Log every URL accepted by the Onion module along with the validation path taken, and retain for post-incident review.
  • Monitor crawler task queue growth from new content sources for anomalous target distributions.

How to Mitigate CVE-2026-100187

Immediate Actions Required

  • Update the AIL Framework deployment to a revision that includes commit 5c8a68b3d8c7d7b03e5febe4ac5b5aca91826adb or later.
  • Audit the Onion crawler task queue and purge entries that do not resolve to valid v3 onion addresses.
  • Restrict ingestion sources to trusted feeds until the patch is deployed.

Patch Information

The fix is delivered in commit 5c8a68b of ail-project/ail-framework. It removes the length-equals-69 shortcut and requires every candidate URL to pass crawlers.get_url_domain() followed by crawlers.is_valid_onion_domain() before being queued.

Workarounds

  • Apply a local patch to bin/modules/Onion.py that removes the len(url) == 69 branch and forces full validation.
  • Enforce an egress firewall policy that permits AIL crawler traffic only to the configured Tor SOCKS proxy.
  • Pause or isolate Onion module workers that process content from untrusted public sources until remediation is confirmed.
bash
# Verify the installed Onion module no longer contains the vulnerable shortcut
grep -n 'len(url) == 69' bin/modules/Onion.py && echo 'VULNERABLE: patch required' || echo 'OK: shortcut removed'

# Pin the patched commit
cd ail-framework
git fetch origin
git checkout 5c8a68b3d8c7d7b03e5febe4ac5b5aca91826adb

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.