Browser Extension Pentesting Methodology

Learn & practice AWS Hacking: Learn & practice GCP Hacking:

Support HackTricks

Check the !
Join the 💬 or the or follow us on Twitter 🐦 .
Share hacking tricks by submitting PRs to the and github repos.

Basic Information

Browser extensions are written in JavaScript and loaded by the browser in the background. It has its but can interact with other sites' DOMs. This means that it may compromise other sites' confidentiality, integrity, and availability (CIA).

Main Components

Extension layouts look best when visualised and consists of three components. Let’s look at each component in depth.

Content Scripts

Each content script has direct access to the DOM of a single web page and is thereby exposed to potentially malicious input. However, the content script contains no permissions other than the ability to send messages to the extension core.

Extension Core

Native Binary

Boundaries

To obtain the user's full privileges, an attacker must convince the extension to pass malicious input from the content script to the extension's core and from the extension's core to the native binary.

Each component of the extension is separated from each other by strong protective boundaries. Each component runs in a separate operating system process. Content scripts and extension cores run in sandbox processes unavailable to most operating system services.

Moreover, content scripts separate from their associated web pages by running in a separate JavaScript heap. The content script and web page have access to the same underlying DOM, but the two never exchange JavaScript pointers, preventing the leaking of JavaScript functionality.

`manifest.json`

Example:

{
  "manifest_version": 2,
  "name": "My extension",
  "version": "1.0",
  "permissions": [
    "storage"
  ],
  "content_scripts": [
    {
      "js": [
        "script.js"
      ],
      "matches": [
        "https://example.com/*",
        "https://www.example.com/*"
      ],
      "exclude_matches": ["*://*/*business*"],
    }
  ],
  "background": {
    "scripts": [
      "background.js"
    ]
  },
  "options_ui": {
    "page": "options.html"
  }
}

`content_scripts`

"content_scripts": [
    {
      "js": [
        "script.js"
      ],
      "matches": [
        "https://example.com/*",
        "https://www.example.com/*"
      ],
      "exclude_matches": ["*://*/*business*"],
    }
  ],

In order to include or exclude more URLs it's also possible to use include_globs and exclude_globs.

chrome.storage.local.get("message", result =>
{
  let div = document.createElement("div");
  div.innerHTML = result.message + " <button>Explain</button>";
  div.querySelector("button").addEventListener("click", () =>
  {
    chrome.runtime.sendMessage("explain");
  });
  document.body.appendChild(div);
});

For viewing and debugging content scripts in Chrome, the Chrome developer tools menu can be accessed from Options > More tools > Developer tools OR by pressing Ctrl + Shift + I.

Upon the developer tools being displayed, the Source tab is to be clicked, followed by the Content Scripts tab. This allows for the observation of running content scripts from various extensions and the setting of breakpoints to track the execution flow.

Injected content scripts

Note that Content Scripts aren't mandatory as it's also possible to dynamically inject scripts and to programatically inject them in web pages via tabs.executeScript. This actually provides more granular controls.

Example activeTab-based extension

manifest.json

{
  "name": "My extension",
  ...
  "permissions": [
    "activeTab",
    "scripting"
  ],
  "background": {
    "service_worker": "background.js"
  },
  "action": {
    "default_title": "Action Button"
  }
}

Inject a JS file on click:

// content-script.js
document.body.style.backgroundColor = "orange";

//service-worker.js - Inject the JS file
chrome.action.onClicked.addListener((tab) => {
  chrome.scripting.executeScript({
    target: { tabId: tab.id },
    files: ["content-script.js"]
  });
});

Inject a function on click:

//service-worker.js - Inject a function
function injectedFunction() {
  document.body.style.backgroundColor = "orange";
}

chrome.action.onClicked.addListener((tab) => {
  chrome.scripting.executeScript({
    target : {tabId : tab.id},
    func : injectedFunction,
  });
});

Example with scripting permissions

// service-workser.js
chrome.scripting.registerContentScripts([{
  id : "test",
  matches : [ "https://*.example.com/*" ],
  excludeMatches : [ "*://*/*business*" ],
  js : [ "contentScript.js" ],
}]);

// Another example
chrome.tabs.executeScript(tabId, { file: "content_script.js" });

In order to include or exclude more URLs it's also possible to use include_globs and exclude_globs.

Content Scripts `run_at`

The run_at field controls when JavaScript files are injected into the web page. The preferred and default value is "document_idle".

The possible values are:

document_idle: Whenever possible
document_start: After any files from css, but before any other DOM is constructed or any other script is run.
document_end: Immediately after the DOM is complete, but before subresources like images and frames have loaded.

Via `manifest.json`

{
  "name": "My extension",
  ...
  "content_scripts": [
    {
      "matches": ["https://*.example.com/*"],
      "run_at": "document_idle",
      "js": ["contentScript.js"]
    }
  ],
  ...
}

Via service-worker.js

chrome.scripting.registerContentScripts([{
  id : "test",
  matches : [ "https://*.example.com/*" ],
  runAt : "document_idle",
  js : [ "contentScript.js" ],
}]);

`background`

Messages sent by content scripts are received by the background page, which serves a central role in coordinating the extension's components. Notably, the background page persists across the extension's lifetime, operating discreetly without direct user interaction. It possesses its own Document Object Model (DOM), enabling complex interactions and state management.

Key Points:

Background Page Role: Acts as the nerve center for the extension, ensuring communication and coordination among various parts of the extension.
Persistence: It's an ever-present entity, invisible to the user but integral to the extension's functionality.
Automatic Generation: If not explicitly defined, the browser will automatically create a background page. This auto-generated page will include all the background scripts specified in the extension's manifest, ensuring the seamless operation of the extension's background tasks.

The convenience provided by the browser in automatically generating a background page (when not explicitly declared) ensures that all necessary background scripts are integrated and operational, streamlining the extension's setup process.

Example background script:

chrome.runtime.onMessage.addListener((request, sender, sendResponse) =>
{
  if (request == "explain")
  {
    chrome.tabs.create({ url: "https://example.net/explanation" });
  }
})

To debug the background script you could go to the extension details and inspect the service worker, this will open the developer tools with the background script:

Options pages and other

Browser extensions can contain various kinds of pages:

Action pages are displayed in a drop-down when the extension icon is clicked.
Pages that the extension will load in a new tab.
Option Pages: This page displays on top of the extension when clicked. In the previous manifest In my case I was able to access this page in chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca or clicking:

Note that these pages aren't persistent like background pages as they load dynamically content on necessity. Despite this, they share certain capabilities with the background page:

Communication with Content Scripts: Similar to the background page, these pages can receive messages from content scripts, facilitating interaction within the extension.
Access to Extension-Specific APIs: These pages enjoy comprehensive access to extension-specific APIs, subject to the permissions defined for the extension.

`permissions` & `host_permissions`

permissions and host_permissions are entries from the manifest.json that will indicate which permissions the browser extensions has (storage, location...) and in which web pages.

As browser extensions can be so privileged, a malicious one or one being compromised could allow the attacker different means to steal sensitive information and spy on the user.

Check how these settings work and how they could get abused in:

`content_security_policy`

A content security policy can be declared also inside the manifest.json. If there is one defined, it could be vulnerable.

The default setting for browser extension pages is rather restrictive:

script-src 'self'; object-src 'self';

For more info about CSP and potential bypasses check:

`web_accessible_resources`

in order for a webpage to access a page of a Browser Extension, a .html page for example, this page needs to be mentioned in the web_accessible_resources field of the manifest.json. For example:

{
 ...
 "web_accessible_resources": [
   {
     "resources": [ "images/*.png" ],
     "matches": [ "https://example.com/*" ]
   },
   {
     "resources": [ "fonts/*.woff" ],
     "matches": [ "https://example.com/*" ]
   }
 ],
 ...
}

These pages are accesible in URL like:

chrome-extension://<extension-id>/message.html

In public extensions the extension-id is accesible:

Although, if the manifest.json parameter use_dynamic_url is used, this id can be dynamic.

Note that even if a page is mentioned here, it might be protected against ClickJacking thanks to the Content Security Policy. So you also need to check it (frame-ancestors section) before confirming a ClickJacking attack is possible.

Being allowed to access these pages make these pages potentially vulnerable ClickJacking:

Allowing these pages to be loaded only by the extension and not by random URLs could prevent ClickJacking attacks.

Note that the pages from web_accessible_resources and other pages of the extension are also capable of contacting background scripts. So if one of these pages is vulnerable to XSS it could open a bigger vulnerability.

Moreover, note that you can only open pages indicated in web_accessible_resources inside iframes, but from a new tab it's possible to access any page in the extension knowing the extension ID. Therefore, if an XSS is found abusing same parameters, it could be abused even if the page isn't configured in web_accessible_resources.

`externally_connectable`

If the externally_connectable key is not declared in your extension's manifest or it's declared as "ids": ["*"], all extensions can connect, but no web pages can connect.
If specific IDs are specified, like in "ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"], only those applications can connect.
If matches are specified, those web apps will be able to connect:

"matches": [
      "https://*.google.com/*",
      "*://*.chromium.org/*",

If it's specified as empty: "externally_connectable": {}, no app or web will be able to connect.

The less extensions and URLs indicated here, the smaller the attack surface will be.

If a web page vulnerable to XSS or takeover is indicated in externally_connectable, an attacker will be able to send messages directly to the background script, completely bypassing the Content Script and its CSP.

Therefore, this is a very powerful bypass.

Communication summary

Extension <--> WebApp

To communicate between the content script and the web page post messages are usually used. Therefore, in the web application you will usually find calls to the function window.postMessage and in the content script listeners like window.addEventListener. Note however, that the extension could also communicate with the web application sending a Post Message (and therefore the web should expect it) or just make the web load a new script.

Inside the extension

Usually the function chrome.runtime.sendMessage is used to send a message inside the extension (usually handled by the background script) and in order to receive and handle it a listener is declared calling chrome.runtime.onMessage.addListener.

It's also possible to use chrome.runtime.connect() to have a persistent connection instead of sending single messages, it's possible to use it to send and receive messages like in the following example:

chrome.runtime.connect() example

var port = chrome.runtime.connect();

// Listen for messages from the web page
window.addEventListener("message", (event) => {
  // Only accept messages from the same window
  if (event.source !== window) {
    return;
  }

  // Check if the message type is "FROM_PAGE"
  if (event.data.type && (event.data.type === "FROM_PAGE")) {
    console.log("Content script received: " + event.data.text);
    // Forward the message to the background script
    port.postMessage({ type: 'FROM_PAGE', text: event.data.text });
  }
}, false);

// Listen for messages from the background script
port.onMessage.addListener(function(msg) {
  console.log("Content script received message from background script:", msg);
  // Handle the response message from the background script
});

It's also possible to send messages from a background script to a content script located in a specific tab calling chrome.tabs.sendMessage where you will need to indicated the ID of the tab to send the message to.

From allowed `externally_connectable` to the extension

Web apps and external browser extensions allowed in the externally_connectable configuration can send requests using :

chrome.runtime.sendMessage(extensionId, ...

Where it's needed to mention the extension ID.

Native Messaging

chrome.runtime.sendNativeMessage(
  'com.my_company.my_application',
  {text: 'Hello'},
  function (response) {
    console.log('Received ' + response);
  }
);

Web ↔︎ Content Script Communication

The environments where content scripts operate and where the host pages exist are separated from one another, ensuring isolation. Despite this isolation, both have the ability to interact with the page's Document Object Model (DOM), a shared resource. For the host page to engage in communication with the content script, or indirectly with the extension through the content script, it is required to utilize the DOM that is accessible by both parties as the communication channel.

Post Messages

content-script.js

// This is like "chrome.runtime.sendMessage" but to maintain the connection
var port = chrome.runtime.connect();

window.addEventListener("message", (event) => {
  // We only accept messages from ourselves
  if (event.source !== window) {
    return;
  }

  if (event.data.type && (event.data.type === "FROM_PAGE")) {
    console.log("Content script received: " + event.data.text);
    // Forward the message to the background script
    port.postMessage(event.data.text);
  }
}, false);

example.js

document.getElementById("theButton").addEventListener("click", () => {
  window.postMessage(
      {type : "FROM_PAGE", text : "Hello from the webpage!"}, "*");
}, false);

A secure Post Message communication should check the authenticity of the received message, this can be done checking:

event.isTrusted: This is True only if the event was triggered by a users action
- The content script might expecting a message only if the user performs some action
origin domain: might expecting a message only allowlist of domains.
- If a regex is used, be very careful
Source: received_message.source !== window can be used to check if the message was from the same window where the Content Script is listening.

The previous checks, even if performed, could be vulnerable, so check in the following page potential Post Message bypasses:

Iframe

Another possible way of communication might be through Iframe URLs, you can find an example in:

DOM

This isn't "exactly" a communication way, but the web and the content script will have access to the web DOM. So, if the content script is reading some information from it, trusting the web DOM, the web could modify this data (because the web shouldn't be trusted, or because the web is vulnerable to XSS) and compromise the Content Script.

You can also find an example of a DOM based XSS to compromise a browser extension in:

Content Script ↔︎ Background Script Communication

To handle the response, use the returned Promise. Although, for backward compatibility, you can still pass a callback as the last argument.

Sending a request from a content script looks like this:

(async () => {
  const response = await chrome.runtime.sendMessage({greeting: "hello"});
  // do something with response here, not outside the function
  console.log(response);
})();

Sending a request from the extension (usually a background script). Example of how to send message to the content script in the selected tab:

// From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
(async () => {
  const [tab] = await chrome.tabs.query({active: true, lastFocusedWindow: true});
  const response = await chrome.tabs.sendMessage(tab.id, {greeting: "hello"});
  // do something with response here, not outside the function
  console.log(response);
})();

// From https://stackoverflow.com/questions/70406787/javascript-send-message-from-content-js-to-background-js
chrome.runtime.onMessage.addListener(
  function(request, sender, sendResponse) {
    console.log(sender.tab ?
                "from a content script:" + sender.tab.url :
                "from the extension");
    if (request.greeting === "hello")
      sendResponse({farewell: "goodbye"});
  }
);

In the example highlighted, sendResponse() was executed in a synchronous fashion. To modify the onMessage event handler for asynchronous execution of sendResponse(), it's imperative to incorporate return true;.

An important consideration is that in scenarios where multiple pages are set to receive onMessage events, the first page to execute sendResponse() for a specific event will be the only one able to deliver the response effectively. Any subsequent responses to the same event will not be taken into account.

When crafting new extensions, the preference should be towards promises as opposed to callbacks. Concerning the use of callbacks, the sendResponse() function is considered valid only if it's executed directly within the synchronous context, or if the event handler indicates an asynchronous operation by returning true. Should none of the handlers return true or if the sendResponse() function is removed from memory (garbage-collected), the callback associated with the sendMessage() function will be triggered by default.

Native Messaging

Browser extensions also allow to communicate with binaries in the system via stdin. The application must install a json indicating so in a json like:

{
  "name": "com.my_company.my_application",
  "description": "My Application",
  "path": "C:\\Program Files\\My Application\\chrome_native_messaging_host.exe",
  "type": "stdio",
  "allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
}

The browser extension also needs the nativeMessaing permission declared in order to be able to use this communication.

This is how it looks like some background script code sending messages to a native application:

chrome.runtime.sendNativeMessage(
  'com.my_company.my_application',
  {text: 'Hello'},
  function (response) {
    console.log('Received ' + response);
  }
);

Browser extension has a wildcard pattern for content script.
Content script passes postMessage messages to the background script using sendMessage.
Background script passes the message to native application using sendNativeMessage.
Native application handles the message dangerously, leading to code execution.

And inside of it an example of going from any page to RCE abusing a browser extension is explained.

Sensitive Information in Memory/Code/Clipboard

If a Browser Extension stores sensitive information inside it's memory, this could be dumped (specially in Windows machines) and searched for this information.

Therefore, the memory of the Browser Extension shouldn't be considered secure and sensitive information such as credentials or mnemonic phrases shouldn't be stored.

Of course, do not put sensitive information in the code, as it will be public.

To dump memory from the browser you could dump the process memory or to go to the settings of the browser extension click on Inspect pop-up -> In the Memory section -> Take a snaphost and CTRL+F to search inside the snapshot for sensitive info.

Moreover, highly sensitive information like mnemonic keys or passwords shouldn't be allowed to be copied in the clipboard (or at least remove it from the clipboard in a few seconds) because then processes monitoring the clipboard will be able to get them.

Loading an Extension in the Browser

Download the Browser Extension & unzipped
Go to chrome://extensions/ and enable the Developer Mode
Click the Load unpacked button

In Firefox you go to about:debugging#/runtime/this-firefox and click Load Temporary Add-on button.

Getting the source code from the store

The source code of a Chrome extension can be obtained through various methods. Below are detailed explanations and instructions for each option.

Download Extension as ZIP via Command Line

The source code of a Chrome extension can be downloaded as a ZIP file using the command line. This involves using curl to fetch the ZIP file from a specific URL and then extracting the contents of the ZIP file to a directory. Here are the steps:

Replace "extension_id" with the actual ID of the extension.
Execute the following commands:

extension_id=your_extension_id   # Replace with the actual extension ID
curl -L -o "$extension_id.zip" "https://clients2.google.com/service/update2/crx?response=redirect&os=mac&arch=x86-64&nacl_arch=x86-64&prod=chromecrx&prodchannel=stable&prodversion=44.0.2403.130&x=id%3D$extension_id%26uc"
unzip -d "$extension_id-source" "$extension_id.zip"

Use the CRX Viewer website

Use the CRX Viewer extension

View source of locally installed extension

Chrome extensions installed locally can also be inspected. Here's how:

Access your Chrome local profile directory by visiting chrome://version/ and locating the "Profile Path" field.
Navigate to the Extensions/ subfolder within the profile directory.
This folder contains all installed extensions, typically with their source code in a readable format.

To identify extensions, you can map their IDs to names:

Enable Developer Mode on the about:extensions page to see the IDs of each extension.
Within each extension's folder, the manifest.json file contains a readable name field, helping you to identify the extension.

Use a File Archiver or Unpacker

Go to the Chrome Web Store and download the extension. The file will have a .crx extension. Change the file extension from .crx to .zip. Use any file archiver (like WinRAR, 7-Zip, etc.) to extract the contents of the ZIP file.

Use Developer Mode in Chrome

Open Chrome and go to chrome://extensions/. Enable "Developer mode" at the top right. Click on "Load unpacked extension...". Navigate to the directory of your extension. This doesn't download the source code, but it's useful for viewing and modifying the code of an already downloaded or developed extension.

Chrome extension manifest dataset

# Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"

Security Audit Checklist

Even though Browser Extensions have a limited attack surface, some of them might contain vulnerabilities or potential hardening improvements. The following ones are the most common ones:

Tools

Pulls any Chrome extension from a provided Chrome webstore link.
Permission Warning(s) viewer: which shows a list of all the Chrome permission prompt warnings which will be displayed upon a user attempting to install the extension.
Dangerous Function(s): shows the location of dangerous functions which could potentially be exploited by an attacker (e.g. functions such as innerHTML, chrome.tabs.executeScript).
Entry Point(s): shows where the extension takes in user/external input. This is useful for understanding an extension’s surface area and looking for potential points to send maliciously-crafted data to the extension.
Both the Dangerous Function(s) and Entry Point(s) scanners have the following for their generated alerts:
- Relevant code snippet and line that caused the alert.
- Description of the issue.
- A “View File” button to view the full source file containing the code.
- The path of the alerted file.
- The full Chrome extension URI of the alerted file.
- The type of file it is, such as a Background Page script, Content Script, Browser Action, etc.
Content Security Policy (CSP) analyzer and bypass checker: This will point out weaknesses in your extension’s CSP and will also illuminate any potential ways to bypass your CSP due to whitelisted CDNs, etc.
Download extension and formatted versions.
- Download the original extension.
- Download a beautified version of the extension (auto prettified HTML and JavaScript).
Automatic caching of scan results, running an extension scan will take a good amount of time the first time you run it. However the second time, assuming the extension hasn’t been updated, will be almost instant due to the results being cached.
Linkable Report URLs, easily link someone else to an extension report generated by tarnish.

Project Neto is a Python 3 package conceived to analyse and unravel hidden features of browser plugins and extensions for well-known browsers such as Firefox and Chrome. It automates the process of unzipping the packaged files to extract these features from relevant resources in a extension like manifest.json, localization folders or Javascript and HTML source files.

References

Support HackTricks

PreviousAccount Takeover NextBrowExt - ClickJacking

Last updated 7 months ago

Basic Information

Main Components

Content Scripts

Extension Core

Native Binary

Boundaries

manifest.json

content_scripts

Injected content scripts

Example activeTab-based extension

Example with scripting permissions

Content Scripts run_at

Via manifest.json

background

Options pages and other

permissions & host_permissions

content_security_policy

web_accessible_resources

externally_connectable

Communication summary

Extension <--> WebApp

Inside the extension

From allowed externally_connectable to the extension

Native Messaging

Web ↔︎ Content Script Communication

Post Messages

Iframe

DOM

Content Script ↔︎ Background Script Communication

Native Messaging

Sensitive Information in Memory/Code/Clipboard

Loading an Extension in the Browser

Getting the source code from the store

Download Extension as ZIP via Command Line

Use the CRX Viewer website

Use the CRX Viewer extension

View source of locally installed extension

Use a File Archiver or Unpacker

Use Developer Mode in Chrome

Chrome extension manifest dataset

Security Audit Checklist

Tools

References

Basic Information

Main Components

Content Scripts

Extension Core

Native Binary

Boundaries

manifest.json

content_scripts

Injected content scripts

Example activeTab-based extension

Example with scripting permissions

Content Scripts run_at

Via manifest.json

background

Options pages and other

permissions & host_permissions

content_security_policy

web_accessible_resources

externally_connectable

Communication summary

Extension <--> WebApp

Inside the extension

From allowed externally_connectable to the extension

Native Messaging

Web ↔︎ Content Script Communication

Post Messages

Iframe

DOM

Content Script ↔︎ Background Script Communication

Native Messaging

Sensitive Information in Memory/Code/Clipboard

Loading an Extension in the Browser

Getting the source code from the store

Download Extension as ZIP via Command Line

Use the CRX Viewer website

Use the CRX Viewer extension

View source of locally installed extension

`manifest.json`

`content_scripts`

Content Scripts `run_at`

Via `manifest.json`

`background`

`permissions` & `host_permissions`

`content_security_policy`

`web_accessible_resources`

`externally_connectable`

From allowed `externally_connectable` to the extension

`manifest.json`

`content_scripts`

Content Scripts `run_at`

Via `manifest.json`

`background`

`permissions` & `host_permissions`

`content_security_policy`

`web_accessible_resources`

`externally_connectable`

From allowed `externally_connectable` to the extension