Browser Extension Pentesting Methodology

```javascript 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 });

</details>

Es ist auch möglich, Nachrichten von einem Hintergrundskript an ein Inhaltskript zu senden, das sich in einem bestimmten Tab befindet, indem **`chrome.tabs.sendMessage`** aufgerufen wird, wobei Sie die **ID des Tabs** angeben müssen, an den die Nachricht gesendet werden soll.

### Von erlaubtem `externally_connectable` zur Erweiterung

**Webanwendungen und externe Browsererweiterungen, die in der `externally_connectable`-Konfiguration erlaubt sind**, können Anfragen senden mit:
```javascript
chrome.runtime.sendMessage(extensionId, ...

Wo es notwendig ist, die Erweiterungs-ID zu erwähnen.

Native Messaging

Es ist möglich, dass die Hintergrundskripte mit Binärdateien im System kommunizieren, die anfällig für kritische Sicherheitsanfälligkeiten wie RCEs sein könnten, wenn diese Kommunikation nicht ordnungsgemäß gesichert ist. Mehr dazu später.

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

Web ↔︎ Kommunikation zwischen Content-Skripten

Die Umgebungen, in denen Content-Skripte arbeiten und wo die Host-Seiten existieren, sind getrennt voneinander, was Isolation gewährleistet. Trotz dieser Isolation haben beide die Möglichkeit, mit dem Document Object Model (DOM) der Seite zu interagieren, einer gemeinsamen Ressource. Damit die Host-Seite mit dem Content-Skript oder indirekt mit der Erweiterung über das Content-Skript kommunizieren kann, ist es erforderlich, das DOM zu nutzen, das für beide Parteien als Kommunikationskanal zugänglich ist.

Post-Nachrichten

// 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);

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

Eine sichere Post Message-Kommunikation sollte die Authentizität der empfangenen Nachricht überprüfen, dies kann durch folgende Punkte geschehen:

• event.isTrusted: Dies ist nur dann True, wenn das Ereignis durch eine Benutzeraktion ausgelöst wurde.

• Das Inhalts-Skript könnte eine Nachricht nur erwarten, wenn der Benutzer eine Aktion ausführt.

• Ursprungsdomäne: könnte eine Nachricht nur von einer erlaubten Liste von Domänen erwarten.

• Wenn ein Regex verwendet wird, seien Sie sehr vorsichtig.

• Quelle: received_message.source !== window kann verwendet werden, um zu überprüfen, ob die Nachricht aus demselben Fenster stammt, in dem das Inhalts-Skript lauscht.

Die vorherigen Überprüfungen könnten, selbst wenn sie durchgeführt werden, anfällig sein, also überprüfen Sie auf der folgenden Seite potenzielle Post Message-Bypässe:

Iframe

Ein weiterer möglicher Kommunikationsweg könnte über Iframe-URLs erfolgen, ein Beispiel finden Sie in:

DOM

Dies ist nicht "genau" ein Kommunikationsweg, aber das Web und das Inhalts-Skript haben Zugriff auf das Web-DOM. Wenn das Inhalts-Skript also Informationen daraus liest und das Web-DOM vertraut, könnte das Web diese Daten modifizieren (weil das Web nicht vertraut werden sollte oder weil das Web anfällig für XSS ist) und das Inhalts-Skript kompromittieren.

Ein Beispiel für ein DOM-basiertes XSS zur Kompromittierung einer Browsererweiterung finden Sie in:

Kommunikation zwischen Inhalts-Skript ↔︎ Hintergrund-Skript

Ein Inhalts-Skript kann die Funktionen runtime.sendMessage() oder tabs.sendMessage() verwenden, um eine einmalige JSON-serialisierbare Nachricht zu senden.

Um die Antwort zu verarbeiten, verwenden Sie das zurückgegebene Promise. Obwohl Sie aus Gründen der Abwärtskompatibilität weiterhin einen Callback als letzten Parameter übergeben können.

Das Senden einer Anfrage von einem Inhalts-Skript sieht so aus:

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

Eine Anfrage von der Erweiterung senden (normalerweise ein Hintergrundskript). Beispiel, wie man eine Nachricht an das Inhaltskript im ausgewählten Tab sendet:

// 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);
})();

Am empfangenden Ende müssen Sie einen runtime.onMessage Ereignis-Listener einrichten, um die Nachricht zu verarbeiten. Dies sieht sowohl aus einem Inhalts-Skript als auch von einer Erweiterungsseite gleich aus.

// 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"});
}
);

Im hervorgehobenen Beispiel wurde sendResponse() synchron ausgeführt. Um den onMessage-Ereignis-Handler für die asynchrone Ausführung von sendResponse() zu modifizieren, ist es unerlässlich, return true; einzufügen.

Eine wichtige Überlegung ist, dass in Szenarien, in denen mehrere Seiten onMessage-Ereignisse empfangen sollen, die erste Seite, die sendResponse() für ein bestimmtes Ereignis ausführt, die einzige sein wird, die die Antwort effektiv liefern kann. Alle nachfolgenden Antworten auf dasselbe Ereignis werden nicht berücksichtigt.

Beim Erstellen neuer Erweiterungen sollte die Präferenz auf Promises anstelle von Callbacks liegen. In Bezug auf die Verwendung von Callbacks wird die Funktion sendResponse() nur dann als gültig angesehen, wenn sie direkt im synchronen Kontext ausgeführt wird oder wenn der Ereignis-Handler eine asynchrone Operation anzeigt, indem er true zurückgibt. Sollten keine der Handler true zurückgeben oder wenn die Funktion sendResponse() aus dem Speicher entfernt wird (garbage-collected), wird der mit der Funktion sendMessage() verbundene Callback standardmäßig ausgelöst.

Native Messaging

Browsererweiterungen ermöglichen auch die Kommunikation mit Binaries im System über stdin. Die Anwendung muss ein JSON installieren, das dies in einem JSON wie folgt angibt:

{
"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/"]
}

Wo der name der String ist, der an runtime.connectNative() oder runtime.sendNativeMessage() übergeben wird, um mit der Anwendung von den Hintergrundskripten der Browsererweiterung zu kommunizieren. Der path ist der Pfad zur Binärdatei, es gibt nur 1 gültigen type, der stdio ist (verwende stdin und stdout) und die allowed_origins geben die Erweiterungen an, die darauf zugreifen können (und dürfen kein Wildcard haben).

Chrome/Chromium wird nach diesem JSON in einigen Windows-Registrierungen und einigen Pfaden in macOS und Linux suchen (weitere Informationen in den docs).

Die Browsererweiterung benötigt auch die nativeMessaing-Berechtigung, um diese Kommunikation nutzen zu können.

So sieht ein Hintergrundskriptcode aus, der Nachrichten an eine native Anwendung sendet:

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

In diesem Blogbeitrag wird ein verwundbares Muster vorgeschlagen, das native Nachrichten missbraucht:

1. Die Browsererweiterung hat ein Wildcard-Muster für das Inhalts-Skript.

2. Das Inhalts-Skript überträgt postMessage-Nachrichten an das Hintergrund-Skript mit sendMessage.

3. Das Hintergrund-Skript überträgt die Nachricht an die native Anwendung mit sendNativeMessage.

4. Die native Anwendung verarbeitet die Nachricht gefährlich, was zu einer Codeausführung führt.

Und darin wird ein Beispiel für den Übergang von jeder Seite zu RCE unter Ausnutzung einer Browsererweiterung erklärt.

Sensible Informationen im Speicher/Code/Clipboard

Wenn eine Browsererweiterung sensible Informationen im Speicher speichert, könnten diese ausgelesen werden (insbesondere auf Windows-Maschinen) und nach diesen Informationen gesucht werden.

Daher sollte der Speicher der Browsererweiterung nicht als sicher betrachtet werden und sensible Informationen wie Anmeldeinformationen oder mnemonische Phrasen sollten nicht gespeichert werden.

Natürlich sollten keine sensiblen Informationen im Code platziert werden, da sie öffentlich sein werden.

Um den Speicher des Browsers auszulesen, könnten Sie den Prozessspeicher auslesen oder zu den Einstellungen der Browsererweiterung gehen, auf Pop-up inspizieren klicken -> Im Speicher-Bereich -> Snapshot erstellen und STRG+F verwenden, um im Snapshot nach sensiblen Informationen zu suchen.

Darüber hinaus sollten hochsensible Informationen wie mnemonische Schlüssel oder Passwörter nicht in die Zwischenablage kopiert werden dürfen (oder zumindest innerhalb weniger Sekunden aus der Zwischenablage entfernt werden), da Prozesse, die die Zwischenablage überwachen, sie dann erhalten können.

Laden einer Erweiterung im Browser

1. Laden Sie die Browsererweiterung herunter und entpacken Sie sie.

2. Gehen Sie zu chrome://extensions/ und aktivieren Sie den Entwicklermodus.

3. Klicken Sie auf die Schaltfläche Entpackte Erweiterung laden.

In Firefox gehen Sie zu about:debugging#/runtime/this-firefox und klicken auf die Schaltfläche Temporäre Erweiterung laden.

Den Quellcode aus dem Store abrufen

Der Quellcode einer Chrome-Erweiterung kann auf verschiedene Weise abgerufen werden. Nachfolgend sind detaillierte Erklärungen und Anweisungen für jede Option aufgeführt.

Erweiterung als ZIP über die Befehlszeile herunterladen

Der Quellcode einer Chrome-Erweiterung kann über die Befehlszeile als ZIP-Datei heruntergeladen werden. Dies beinhaltet die Verwendung von curl, um die ZIP-Datei von einer bestimmten URL abzurufen und dann den Inhalt der ZIP-Datei in ein Verzeichnis zu extrahieren. Hier sind die Schritte:

1. Ersetzen Sie "extension_id" durch die tatsächliche ID der Erweiterung.

2. Führen Sie die folgenden Befehle aus:

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"

Verwenden Sie die CRX Viewer-Website

https://robwu.nl/crxviewer/

Verwenden Sie die CRX Viewer-Erweiterung

Eine weitere praktische Methode ist die Verwendung des Chrome Extension Source Viewers, einem Open-Source-Projekt. Es kann aus dem Chrome Web Store installiert werden. Der Quellcode des Viewers ist in seinem GitHub-Repository verfügbar.

Quellcode der lokal installierten Erweiterung anzeigen

Chrome-Erweiterungen, die lokal installiert sind, können ebenfalls inspiziert werden. So geht's:

1. Greifen Sie auf Ihr lokales Chrome-Profilverzeichnis zu, indem Sie chrome://version/ besuchen und das Feld "Profilpfad" finden.

2. Navigieren Sie zum Unterordner Extensions/ innerhalb des Profilverzeichnisses.

3. Dieser Ordner enthält alle installierten Erweiterungen, typischerweise mit ihrem Quellcode in einem lesbaren Format.

Um Erweiterungen zu identifizieren, können Sie deren IDs den Namen zuordnen:

• Aktivieren Sie den Entwicklermodus auf der Seite about:extensions, um die IDs jeder Erweiterung zu sehen.

• Innerhalb des Ordners jeder Erweiterung enthält die Datei manifest.json ein lesbares name-Feld, das Ihnen hilft, die Erweiterung zu identifizieren.

Verwenden Sie einen Dateiarchivier oder -depacker

Gehen Sie zum Chrome Web Store und laden Sie die Erweiterung herunter. Die Datei hat die Erweiterung .crx. Ändern Sie die Dateierweiterung von .crx in .zip. Verwenden Sie einen beliebigen Dateiarchivier (wie WinRAR, 7-Zip usw.), um den Inhalt der ZIP-Datei zu extrahieren.

Entwicklermodus in Chrome verwenden

Öffnen Sie Chrome und gehen Sie zu chrome://extensions/. Aktivieren Sie "Entwicklermodus" oben rechts. Klicken Sie auf "Entpackte Erweiterung laden...". Navigieren Sie zum Verzeichnis Ihrer Erweiterung. Dies lädt den Quellcode nicht herunter, ist jedoch nützlich, um den Code einer bereits heruntergeladenen oder entwickelten Erweiterung anzuzeigen und zu ändern.

Chrome-Erweiterungsmanifest-Datensatz

Um zu versuchen, anfällige Browsererweiterungen zu erkennen, können Sie das https://github.com/palant/chrome-extension-manifests-dataset verwenden und deren Manifestdateien auf potenziell anfällige Anzeichen überprüfen. Zum Beispiel, um nach Erweiterungen mit mehr als 25000 Benutzern, content_scripts und der Berechtigung nativeMessaging zu suchen:

# 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')"

Sicherheitsprüfliste

Obwohl Browsererweiterungen eine begrenzte Angriffsfläche haben, können einige von ihnen Schwachstellen oder potenzielle Verbesserungen aufweisen. Die folgenden sind die häufigsten:

• Berechtigungen so weit wie möglich einschränken

• Host-Berechtigungen so weit wie möglich einschränken

• Verwenden Sie eine starke content_security_policy

• Einschränken Sie so weit wie möglich die externally_connectable, wenn keine benötigt wird und möglich ist, lassen Sie es nicht standardmäßig, geben Sie {} an

• Wenn hier eine URL, die anfällig für XSS oder Übernahme ist, erwähnt wird, kann ein Angreifer Nachrichten direkt an die Hintergrundskripte senden. Sehr mächtiger Umgehung.

• Einschränken Sie so weit wie möglich die web_accessible_resources, sogar leer, wenn möglich.

• Wenn web_accessible_resources nicht leer ist, überprüfen Sie ClickJacking

• Wenn eine Kommunikation von der Erweiterung zur Webseite erfolgt, überprüfen Sie auf XSS Schwachstellen, die in der Kommunikation verursacht werden.

• Wenn Post-Nachrichten verwendet werden, überprüfen Sie auf Post-Nachrichten-Schwachstellen.

• Wenn das Inhalts-Skript auf DOM-Details zugreift, überprüfen Sie, ob sie kein XSS einführen, wenn sie von der Webseite modifiziert werden

• Legen Sie besonderen Wert darauf, wenn diese Kommunikation auch an der Kommunikation zwischen Inhalts-Skript und Hintergrundskript beteiligt ist

• Wenn das Hintergrundskript über native Messaging kommuniziert, überprüfen Sie, ob die Kommunikation sicher und bereinigt ist

• Sensible Informationen sollten nicht im Code der Browsererweiterung gespeichert werden

• Sensible Informationen sollten nicht im Speicher der Browsererweiterung gespeichert werden

• Sensible Informationen sollten nicht im Dateisystem ungeschützt gespeichert werden

Werkzeuge

Tarnish

• Zieht jede Chrome-Erweiterung von einem bereitgestellten Chrome-Webstore-Link.

• manifest.json Viewer: zeigt einfach eine JSON-hübsch formatierte Version des Manifests der Erweiterung an.

• Fingerprint-Analyse: Erkennung von web_accessible_resources und automatische Generierung von JavaScript zur Fingerabdruckerkennung von Chrome-Erweiterungen.

• Potenzielle Clickjacking-Analyse: Erkennung von HTML-Seiten der Erweiterung mit der web_accessible_resources-Richtlinie. Diese sind potenziell anfällig für Clickjacking, abhängig vom Zweck der Seiten.

• Berechtigungswarnungen Viewer: zeigt eine Liste aller Chrome-Berechtigungsaufforderungswarnungen, die angezeigt werden, wenn ein Benutzer versucht, die Erweiterung zu installieren.

• Gefährliche Funktion(en): zeigt den Standort gefährlicher Funktionen, die potenziell von einem Angreifer ausgenutzt werden könnten (z. B. Funktionen wie innerHTML, chrome.tabs.executeScript).

• Einstiegspunkt(e): zeigt, wo die Erweiterung Benutzereingaben oder externe Eingaben entgegennimmt. Dies ist nützlich, um die Angriffsfläche einer Erweiterung zu verstehen und nach potenziellen Punkten zu suchen, um bösartig gestaltete Daten an die Erweiterung zu senden.

• Sowohl die Scanner für gefährliche Funktion(en) als auch Einstiegspunkt(e) haben Folgendes für ihre generierten Warnungen:

• Relevanter Codeausschnitt und Zeile, die die Warnung verursacht hat.

• Beschreibung des Problems.

• Eine Schaltfläche „Datei anzeigen“, um die vollständige Quelldatei mit dem Code anzuzeigen.

• Der Pfad der gewarnten Datei.

• Die vollständige Chrome-Erweiterungs-URI der gewarnten Datei.

• Den Typ der Datei, z. B. ein Hintergrundseiten-Skript, Inhalts-Skript, Browser-Aktion usw.

• Wenn die anfällige Zeile in einer JavaScript-Datei ist, die Pfade aller Seiten, auf denen sie enthalten ist, sowie den Typ dieser Seiten und den Status der web_accessible_resource.

• Content Security Policy (CSP) Analyzer und Umgehungsprüfer: Dies wird Schwächen in der CSP Ihrer Erweiterung aufzeigen und auch potenzielle Möglichkeiten zur Umgehung Ihrer CSP aufgrund von aufgelisteten CDNs usw. aufzeigen.

• Bekannte anfällige Bibliotheken: Dies verwendet Retire.js, um die Verwendung bekannter anfälliger JavaScript-Bibliotheken zu überprüfen.

• Erweiterung und formatierte Versionen herunterladen.

• Die originale Erweiterung herunterladen.

• Eine verschönerte Version der Erweiterung herunterladen (automatisch hübsch formatierte HTML- und JavaScript).

• Automatische Zwischenspeicherung der Scannergebnisse, das Ausführen eines Erweiterungsscans dauert beim ersten Ausführen eine gute Zeit. Beim zweiten Mal, vorausgesetzt, die Erweiterung wurde nicht aktualisiert, wird es fast sofort sein, da die Ergebnisse zwischengespeichert werden.

• Verlinkbare Bericht-URLs, um jemand anderem leicht einen von Tarnish generierten Erweiterungsbericht zu verlinken.

Neto

Projekt Neto ist ein Python 3-Paket, das entwickelt wurde, um versteckte Funktionen von Browser-Plugins und -Erweiterungen für bekannte Browser wie Firefox und Chrome zu analysieren und zu entschlüsseln. Es automatisiert den Prozess des Entpackens der gepackten Dateien, um diese Funktionen aus relevanten Ressourcen in einer Erweiterung wie manifest.json, Lokalisierungsordnern oder JavaScript- und HTML-Quelldateien zu extrahieren.

Referenzen

• Danke an @naivenom für die Hilfe mit dieser Methodik

• https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing

• https://palant.info/2022/08/10/anatomy-of-a-basic-extension/

• https://palant.info/2022/08/24/attack-surface-of-extension-pages/

• https://palant.info/2022/08/31/when-extension-pages-are-web-accessible/

• https://help.passbolt.com/assets/files/PBL-02-report.pdf

• https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts

• https://developer.chrome.com/docs/extensions/mv2/background-pages

• https://thehackerblog.com/kicking-the-rims-a-guide-for-securely-writing-and-auditing-chrome-extensions/

• https://gist.github.com/LongJohnCoder/9ddf5735df3a4f2e9559665fb864eac0

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)