Erweiterungen haben Zugriff auf spezielle Berechtigungen innerhalb des Browsers, was sie zu einem attraktiven Ziel für Angreifer macht. Wenn eine Erweiterung manipuliert wird, ist jeder Nutzer dieser Erweiterung anfällig für schädliche und unerwünschte Angriffe. Sorgen Sie dafür, dass Erweiterungen und ihre Nutzer durch diese Methoden sicher sind.
Entwicklerkonten schützen
Der Erweiterungscode wird über Google-Konten hochgeladen und aktualisiert. Wenn Entwicklerkonten gehackt werden, könnte ein Angreifer schädlichen Code direkt an alle Nutzer übertragen. Schützen Sie diese Konten, indem Sie die 2-Faktor-Authentifizierung aktivieren, vorzugsweise mit einem Sicherheitsschlüssel.
Gruppenauswahl auswählen
Wenn Sie die Gruppenveröffentlichung verwenden, beschränken Sie die Gruppe auf vertrauenswürdige Entwickler. Akzeptieren Sie keine Beitrittsanfragen von unbekannten Personen.
Nie HTTP verwenden
Vermeiden Sie beim Anfordern oder Senden von Daten eine HTTP-Verbindung. Gehen Sie davon aus, dass HTTP-Verbindungen mitgelesen werden oder Änderungen daran enthalten sein werden. HTTPS sollte immer bevorzugt werden, da es integrierte Sicherheitsfunktionen bietet, die die meisten Man-in-the-Middle-Angriffe umgehen.
Minimale Berechtigungen anfordern
Im Chrome-Browser wird der Zugriff einer Erweiterung auf Berechtigungen beschränkt, die explizit im Manifest angefordert wurden. Erweiterungen sollten ihre Berechtigungen minimieren, indem sie nur APIs und Websites registrieren, von denen sie abhängig sind.
Das Einschränken der Berechtigungen einer Erweiterung schränkt die aus, die ein potenzieller Angreifer ausnutzen kann.
Ursprungsübergreifender Abruf()
Eine Erweiterung kann nur fetch() und XMLHttpRequest() verwenden, um Ressourcen von der Erweiterung und von Domains abzurufen, die in den Berechtigungen angegeben sind. Aufrufe an beide werden vom fetch-Handler im Service Worker abgefangen.
{
"name": "Very Secure Extension",
"version": "1.0",
"description": "Example of a Secure Extension",
"host_permissions": [
"https://developer.chrome.com/*",
"https://*.google.com/*"
],
"manifest_version": 3
}
Diese Erweiterung im Beispiel oben fordert Zugriff auf alle Inhalte auf developer.chrome.com und Subdomains von Google an. Dazu werden "https://developer.chrome.com/*" und "https://*.google.com/*" in den Berechtigungen aufgeführt. Würde die Erweiterung manipuliert, hätte sie weiterhin nur die Berechtigung zur Interaktion mit Websites, die dem Übereinstimmungsmuster entsprechen. Der Angreifer hätte nur begrenzte Möglichkeiten, auf "https://user_bank_info.com" zuzugreifen oder mit "https://malicious_website.com" zu interagieren.
Manifestfelder beschränken
Wenn Sie dem Manifest unnötige Schlüssel und Berechtigungen hinzufügen, entstehen Sicherheitslücken und Erweiterungen werden sichtbarer. Beschränken Sie Manifestfelder auf diejenigen, die für die Erweiterung benötigt werden.
Extern verbunden
Im Feld "externally_connectable" geben Sie an, mit welchen externen Erweiterungen und Webseiten die Erweiterung Informationen austauscht. Beschränken Sie auf vertrauenswürdige Quellen, mit wem die Erweiterung extern Verbindungen herstellen kann.
{
"name": "Super Safe Extension",
"externally_connectable": {
"ids": [
"iamafriendlyextensionhereisdatas"
],
"matches": [
"https://developer.chrome.com/*",
"https://*.google.com/*"
],
"accepts_tls_channel_id": false
},
...
}
Über das Web zugängliche Ressourcen
Wenn Ressourcen über das Web unter der "web_accessible_resources" zugänglich werden, wird eine Erweiterung von Websites und Angreifern erkennbar.
{
...
"web_accessible_resources": [
{
"resources": [ "test1.png", "test2.png" ],
"matches": [ "https://web-accessible-resources-1.glitch.me/*" ]
}
]
...
}
Je mehr über das Internet zugängliche Ressourcen zur Verfügung stehen, desto mehr Möglichkeiten stehen potenziellen Angreifern zur Verfügung. Beschränken Sie diese Dateien auf ein Minimum.
Explizite Content Security Policy hinzufügen
Fügen Sie dem Manifest eine Sicherheitsrichtlinie für Inhalte für die Erweiterung hinzu, um Cross-Site-Scripting-Angriffe zu verhindern. Wenn die Erweiterung Ressourcen nur aus sich selbst lädt, registrieren Sie Folgendes:
{
"name": "Very Secure Extension",
"version": "1.0",
"description": "Example of a Secure Extension",
"content_security_policy": {
"extension_pages": "default-src 'self'"
},
"manifest_version": 3
}
Wenn die Erweiterung Web Assembly verwenden oder die Einschränkungen für Seiten in einer Sandbox erhöhen muss, können Sie die Erweiterung hinzufügen:
{
"name": "Very Secure Extension",
"version": "1.0",
"description": "Example of a Secure Extension",
"content_security_policy": {
"extension_pages": "script-src 'self' 'wasm-unsafe-eval'; object-src 'self';",
"sandboxed_pages":"script-src 'self' 'wasm-unsafe-eval'; object-src 'self';"
},
"manifest_version": 3
}
„document.write()“ und „innerHTML“ vermeiden
Es mag einfacher sein, HTML-Elemente mit document.write() und innerHTML dynamisch zu erstellen, dabei bleiben jedoch die Erweiterung und die Webseiten, von denen die Erweiterung abhängig ist, offen für Angreifer, die schädliche Skripts einfügen. Erstellen Sie stattdessen manuell DOM-Knoten und verwenden Sie innerText, um dynamische Inhalte einzufügen.
function constructDOM() {
let newTitle = document.createElement('h1');
newTitle.innerText = host;
document.appendChild(newTitle);
}
Inhaltsskripte mit Bedacht einsetzen
Inhaltsskripts befinden sich zwar in einer isolierten Welt, sind aber nicht vor Angriffen geschützt:
- Inhaltsskripte sind der einzige Teil einer Erweiterung, die direkt mit der Webseite interagiert. Daher können feindselige Webseiten Teile des DOM manipulieren, von dem das Inhaltsskript abhängt, oder überraschende Webstandards wie benannte Elemente ausnutzen.
- Um mit dem DOM von Webseiten zu interagieren, müssen Inhaltsskripts im selben Rendererprozess wie die Webseite ausgeführt werden. Dadurch werden Inhaltsscripts anfällig für Datenlecks über Side-Channel-Angriffe (z.B. Spectre) und kann von einem Angreifer übernommen werden, wenn eine schädliche Webseite den Rendererprozess manipuliert.
Vorgänge, bei denen sensible Daten (z. B. private Informationen eines Nutzers) oder Chrome-APIs mit Zugriff auf die Funktionen des Browsers verwendet werden, sollten im Service Worker der Erweiterung ausgeführt werden. Vermeiden Sie es, versehentlich Erweiterungsberechtigungen für Inhaltsskripte offenzulegen:
- Du kannst davon ausgehen, dass Nachrichten aus einem Inhaltsskript von einem Angreifer erstellt wurden. Validiere und bereinigen Sie beispielsweise alle Eingaben und schützen Sie Ihre Scripts vor websiteübergreifendem Scripting.
- Sie gehen davon aus, dass an das Inhaltsskript gesendete Daten in die Webseite gelangen könnten. Senden Sie keine sensiblen Daten (z.B. Secrets von der Erweiterung, Daten von anderen Webursprüngen oder der Browserverlauf) an Inhaltsskripte.
- Beschränken Sie den Umfang der privilegierten Aktionen, die von Content-Skripts ausgelöst werden können. Sie dürfen nicht zulassen, dass Inhaltsskripte Anfragen an beliebige URLs auslösen oder beliebige Argumente an Erweiterungs-APIs übergeben. Übergeben Sie beispielsweise keine beliebigen URLs an die Methoden
fetch()oderchrome.tabs.create().
Eingaben registrieren und bereinigen
Schützen Sie eine Erweiterung vor schädlichen Skripts, indem Sie Listener auf das beschränken, was die Erweiterung erwartet, die Absender eingehender Daten validieren und alle Eingaben bereinigen.
Eine Erweiterung sollte nur dann für runtime.onMessageExternal registriert werden, wenn sie Kommunikation von einer externen Website oder Erweiterung erwartet. Prüfen Sie immer, ob der Absender mit einer vertrauenswürdigen Quelle übereinstimmt.
// The ID of an external extension
const kFriendlyExtensionId = "iamafriendlyextensionhereisdatas";
chrome.runtime.onMessageExternal.addListener(
function(request, sender, sendResponse) {
if (sender.id === kFriendlyExtensionId)
doSomething();
});
Sogar Nachrichten, die über ein runtime.onMessage-Ereignis von der Erweiterung selbst gesendet wurden, sollten geprüft werden, um sicherzustellen, dass MessageSender nicht aus einem manipulierten Inhaltsskript stammt.
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
if (request.allowedAction)
console.log("This is an allowed action.");
});