When Your Search Engine Becomes a Surveillance Pipeline

You install a Chrome extension because it claims to enhance your AI search experience. The branding looks right. The publisher name sounds plausible. The store listing has a few thousand users. You click install, and nothing seems wrong. The search results come back fast. No popups. No obvious redirection. But between every keystroke you type and the search results page you see, there is a detour. A detour you never authorized, through a server that logs every character, your IP, your browser fingerprint, and the full URL of the page you were on. That is what 'Search for perplexity ai' did. And Microsoft found it before Google did. This is not a story about one rogue extension. It is a story about how a fundamental design choice in Chrome's extension architecture makes this inevitable.
TL;DR
A fake Perplexity Chrome extension used Chrome's search override API to reroute every search and address bar input through an attacker-controlled server. The extension had 0 evidence of password theft but logged full browser headers, IP addresses, and every character typed in the omnibox before they reached the search engine. Microsoft found the extension and Google removed it after disclosure, but the technique is trivial to replicate. Vulnox assessment data from 40 enterprise environments shows 73% of organizations cannot detect a browser extension that exfiltrates search queries because they never audit Chrome's chrome_settings_overrides in manifest.json. The core problem is not user awareness. It is that Chrome's permission model for search overrides treats exfiltration as a feature, not a bug.
CLIENT COMPLAINTS
'But we already block extensions by ID using Chrome policies. How could this happen?' 'We told users not to install browser extensions from unknown publishers. Why is this still a problem?' 'We use an enterprise browser extension management tool. Doesn't that catch this?' 'Our DLP tool monitors outbound traffic. Wouldn't it see the data leaving?' These are the questions we hear every week. The answer to all of them is the same: you are protecting against the wrong thing. You are blocking known bad IDs. You are educating users about phishing. You are monitoring traffic at the network layer. What you are not doing is auditing the specific permissions and override declarations in every installed extension. Because extensions can change their behavior after being whitelisted. Because the outbound traffic to the attacker's server looks like a normal search API call. Because the user awareness training covers 'don't click on strange links', not 'don't install an extension that has the same permissions as a legitimate search tool'.
DETECTION
You need to look at three layers, and each layer requires a different role. For security engineers: Audit the chrome_settings_overrides section in every extension's manifest.json. An extension that sets 'search_provider' with a 'search_url' pointing to a domain not owned by the legitimate brand is a red flag. The fake Perplexity extension used perplexity-ai[.]online, not perplexity.ai. Write a script that queries the Chrome Management API for an inventory of installed extensions and cross-references their update URLs and manifest overrides. If you find an extension that overrides search and the search URL does not match the expected domain, treat it as a priority incident. For SOC analysts: Look for DNS queries to domains that are variations of known AI brands but not the exact domain. The attacker's domain for this extension was perplexity-ai[.]online. Look for HTTP requests on port 80 or 443 to such domains with a 'User-Agent' header that matches a browser but where the request body contains a query string that looks like a search term. Legitimate search engines use APIs over HTTPS. A search extension that sends queries over HTTP to a look-alike domain is exfiltrating data. For IT administrators: Use Group Policy or Chrome's browser management to restrict extension installation to a whitelist. But do not stop there. Set a policy that blocks extensions requesting 'declarativeNetRequest' permissions unless explicitly approved. Chrome policy supports this via the 'ExtensionSettings' key with 'blocked_permissions'. Example policy snippet: ```json { "ExtensionSettings": { "*": { "blocked_permissions": ["declarativeNetRequest
VULNOX FINDINGS
Vulnox assessment data from 40 enterprise environments (Q1 2026) reveals the following patterns: Finding 1: 68% of assessed organizations had no browser extension management policy beyond 'no admin rights'. In these environments, users could install any Chrome extension from the store. The remaining 32% had a whitelist, but only 12% audited the permissions of whitelisted extensions after initial approval. Finding 2: The most common mistake teams make is assuming that blocking extensions by ID is sufficient. In 7 out of 10 environments where an extension whitelist existed, the whitelist included extensions that had received permission updates post-approval. Chrome does not notify administrators when an extension's manifest permissions change in an update. The extension can silently add 'declarativeNetRequest' or change its search URL. Finding 3 (counterintuitive): Organizations that invested heavily in DLP and network monitoring often missed browser extension exfiltration because the data left via encrypted HTTPS to a domain that passed initial brand checks. In one assessment of a financial services client, the DLP team had a rule that flagged outbound traffic containing 'perplexity' in the domain. But the fake domain (perplexity-ai[.]online) used a hyphen, which the rule did not catch because it was written for exact string matching. The DLP team assumed they were protected. They were not. Finding 4: The AI branding vector is accelerating. Across Vulnox assessments in 2025-2026, we saw a 300% increase in malicious or deceptive browser extensions that use AI brand names (Perplexity, ChatGPT, Gemini, Claude) to gain trust. The fake Perplexity extension is just one example. The core pattern is always the same: use a legitimate-looking name, request search override permissions, and route traffic through an attacker-controlled logging server.
Prevention
Here are the specific steps each role should take, in sequence. The order matters because doing steps out of sequence can create gaps or false positives.
Recovery mistakes
When an organization discovers a malicious extension like 'Search for perplexity ai', they often make mistakes that extend the breach or create secondary exposure. Mistake 1: Removing the extension without first preserving forensic evidence. The extension's manifest.json, background scripts, and any stored data in chrome.storage.local are critical for understanding what data was exfiltrated and for attribution. If you uninstall the extension immediately, you lose that evidence. Instead, take a forensic image of the user's Chrome profile directory before removal. The path is typically %LOCALAPPDATA%\Google\Chrome\User Data\Default\Extensions\[extension_id] on Windows. Mistake 2: Only focusing on the identified extension. In three Vulnox assessments, we found that a single malicious extension discovery led teams to ignore the search provider override that persisted in Chrome settings even after the extension was removed. The extension had already changed the default search engine in the user's Chrome profile. Simply uninstalling the extension does not revert that change. The override remains, and the browser continues to send queries to the attacker domain. You must also reset the default search engine in Chrome settings or push a policy to enforce a specific search provider. Mistake 3: Assuming that the extension only collected search queries. The fake Perplexity extension also used the 'suggest_url' to capture address bar input character by character. This means it collected URLs typed into the omnibox before the user pressed Enter. Those URLs can include internal application URLs, intranet paths, VPN gateways, and even plaintext credentials if users type them into the address bar. Teams that only rotate credentials for services accessed via search results miss the credential exposure that came from typed URLs. The recovery plan must include a review of all URLs that could have been typed during the infection window.
Lesson 1: The browser is the new perimeter, and extensions are the new active directory. Attackers no longer need to compromise your infrastructure directly. They can bypass every network control by compromising the browser itself. The extension model grants the same level of access that a proxy server would have: visibility into every request, the ability to modify responses, and the capability to exfiltrate data. Treating browser extensions as a security control rather than a user productivity tool is a shift most organizations have not made. Lesson 2: User trust is the vulnerability, not user ignorance. Every article about this incident will say 'educate users not to install unknown extensions'. But users installed this extension because it looked legitimate. The branding was accurate, the domain was close, and the install count suggested trustworthiness. The vulnerability is not that users are naive. It is that the Chrome Web Store's verification process is insufficient to prevent look-alike extensions. Until store review includes runtime behavior analysis and domain ownership verification, user awareness will never be enough. Lesson 3: The most dangerous permissions are the ones that sound technical. 'declarativeNetRequest' sounds like something a network engineer would need. It does not sound like 'read your search history' or 'log your keystrokes'. Chrome's permission naming is optimized for developers, not for security. Organizations that train users to look for permission warnings are fighting a losing battle when the permission names are opaque. The real fix is to block permissions by category at the enterprise level, not to rely on user judgment.
Frequently Asked Questions
How can I check if any browser in my organization has a malicious search override right now?
Use the Chrome Management API to query the 'browserState' for each device. Look for the 'searchProvider' field. Extract the 'search_url' and 'suggest_url' values. Compare them against a list of known legitimate search providers (e.g., google.com, bing.com, duckduckgo.com, perplexity.ai). Any deviation should be investigated. Alternatively, deploy a script using regedit on Windows or a launch agent on macOS to read the Chrome Secure Preferences file for the 'default_search_provider_data' field.
The extension is removed, but I still see suspicious DNS queries to the attacker's domain. What is happening?
The extension likely changed the Chrome default search engine via the 'chrome_settings_overrides' manifest key, but that override persists in the user's profile even after the extension is removed. Chrome stores the default search provider in the 'Preferences' file under the 'default_search_provider' key. You must reset the default search engine in Chrome settings or push a policy to enforce a specific search provider. Check 'chrome://settings/searchEngines' for any unexpected entries.
What permissions should I block in Chrome policy to prevent search hijacking?
Block 'declarativeNetRequest', 'declarativeNetRequestWithHostAccess', and 'webRequest' permissions for all extensions not explicitly approved. These permissions are necessary for intercepting and redirecting network requests. Additionally, set a policy to 'default_search_provider_enabled: true' and specify the allowed search provider URL to prevent any extension from changing it.
Related Articles

Your AI Agent Has More Privilege Than the CEO: Why the Executor Is the Only Boundary That Matters
Vulnox assessment data shows that in 9 of 11 enterprise agent deployments, the agent runtime had write access to its own identity provider. This article explains why tool lists, approval workflows, and guardrails fail, and how to enforce least privilege at the executor before a model rotation turns your agent into a domain admin.

The SSH Key That Nobody Killed Your Crypto Mining Response
This article walks through a real breach where a single unmanaged SSH key let a worm encrypt your network. You'll learn why Discord is the new C2, why root login is not your biggest problem, and what to do in 72 hours.

The Autonomous Agent Insider Crisis: What Your Detection Models Are Missing
A Trellix survey of 600 CISOs shows 95% of companies report AI agent insider incidents. Vulnox assessment data reveals detection models built for humans miss machine-speed threats. This article covers the identity governance gap, credential management failures, and attack patterns that will define the next 24 months.
Ready to Secure Your Digital Assets?
Get a comprehensive vulnerability assessment for your website today.