Le estensioni hanno accesso a privilegi speciali all'interno del browser, il che le rende un bersaglio accattivante per gli utenti malintenzionati. Se un'estensione viene compromessa, ogni utente di quell'estensione diventa vulnerabile a intrusioni dannose e indesiderate. Proteggi un'estensione e i suoi utenti incorporando queste pratiche.
Proteggere gli account sviluppatore
Il codice dell'estensione viene caricato e aggiornato tramite gli Account Google. Se gli account degli sviluppatori vengono compromessi, un utente malintenzionato potrebbe inviare codice dannoso direttamente a tutti gli utenti. Proteggi questi account creando account sviluppatore specifici e attivando l'autenticazione a due fattori , preferibilmente con un token di sicurezza .
Mantieni selettivi i gruppi
Se utilizzi la pubblicazione di gruppo, tieni il gruppo limitato a sviluppatori affidabili. Non accettare richieste di adesione da persone sconosciute.
Non usare mai HTTP
Quando richiedi o invii dati, evita una connessione HTTP. Supponiamo che le connessioni HTTP abbiano intercettazioni o contengano modifiche. Il protocollo HTTPS dovrebbe essere sempre preferibile, poiché dispone di sicurezza integrata che aggira la maggior parte degli attacchi man in the middle.
Richiedi autorizzazioni minime
Il browser Chrome limita l'accesso di un'estensione ai privilegi richiesti esplicitamente nel manifest. Le estensioni dovrebbero ridurre al minimo le autorizzazioni registrando solo le API e i siti web da cui dipendono. Il codice arbitrario deve essere ridotto al minimo.
Limitare i privilegi di un'estensione limita ciò che un potenziale utente malintenzionato può sfruttare.
XMLHttpRequest multiorigine
Un'estensione può utilizzare XMLHttpRequest solo per ottenere risorse da se stessa e dai domini specificati nelle autorizzazioni.
{
"name": "Very Secure Extension",
"version": "1.0",
"description": "Example of a Secure Extension",
"permissions": [
"/*",
"https://*.google.com/"
],
"manifest_version": 2
}
Questa estensione richiede l'accesso a qualsiasi elemento presente su developer.chrome.com e nei sottodomini di Google specificando "/*"
e "https://*google.com/"
nelle autorizzazioni. Se l'estensione venisse compromessa, sarebbe comunque autorizzata a interagire con i siti web che soddisfano il pattern di corrispondenza. L'utente malintenzionato non potrebbe accedere a "https://user_bank_info.com"
o
interagire con "https://malicious_website.com"
.
Limita i campi del manifest
L'inclusione di registrazioni non necessarie nel manifest crea vulnerabilità e rende più visibile un'estensione. Limita i campi manifest a quelli su cui si basa l'estensione e concedi la registrazione di campi specifici.
Collegabile esternamente
Utilizza il campo externally_connectable
per dichiarare con quali estensioni esterne e pagine web
l'estensione scambierà informazioni. Limita alle origini attendibili le persone con cui l'estensione può connettersi esternamente.
{
"name": "Super Safe Extension",
"externally_connectable": {
"ids": [
"iamafriendlyextensionhereisdatas"
],
"matches": [
"/*",
"https://*google.com/"
],
"accepts_tls_channel_id": false
},
...
}
Risorse accessibili dal web
Rendendo le risorse accessibili sul web, nel web_accessible_resources
verrà resa
rilevabile l'estensione da parte di siti web e utenti malintenzionati.
{
...
"web_accessible_resources": [
"images/*.png",
"style/secure_extension.css",
"script/secure_extension.js"
],
...
}
Maggiore è il numero di risorse accessibili sul web, maggiori sono le opportunità che un potenziale utente malintenzionato può sfruttare. Riduci al minimo questi file.
Includere criteri di sicurezza dei contenuti espliciti
Includi nel file manifest un criterio di sicurezza dei contenuti per l'estensione, in modo da impedire attacchi di cross-site scripting (XSS). Se l'estensione carica le risorse solo da se stessa, registra quanto segue:
{
"name": "Very Secure Extension",
"version": "1.0",
"description": "Example of a Secure Extension",
"content_security_policy": "default-src 'self'"
"manifest_version": 2
}
Se l'estensione deve includere script di host specifici, questi possono essere inclusi:
{
"name": "Very Secure Extension",
"version": "1.0",
"description": "Example of a Secure Extension",
"content_security_policy": "default-src 'self' https://extension.resource.com"
"manifest_version": 2
}
Evita le API eseguibili
Le API che eseguono codice dovrebbero essere sostituite con alternative più sicure.
document.write() e innerHTML
Anche se potrebbe essere più semplice creare dinamicamente elementi HTML con document.write()
e innerHTML
, l'estensione e le pagine web da cui dipende l'estensione rimangono aperte ai malintenzionati che inseriscono script dannosi. Crea invece manualmente i nodi DOM e utilizza innerText
per inserire contenuti dinamici.
function constructDOM() {
let newTitle = document.createElement('h1');
newTitle.innerText = host;
document.appendChild(newTitle);
}
eval()
Se possibile, evita di utilizzare eval()
per prevenire gli attacchi, dato che eval()
eseguirà il codice trasmesso al suo interno, che potrebbe essere dannoso.
var xhr = new XMLHttpRequest();
xhr.open("GET", "https://api.example.com/data.json", true);
xhr.onreadystatechange = function() {
if (xhr.readyState == 4) {
// WARNING! Might be evaluating an evil script!
var resp = eval("(" + xhr.responseText + ")");
...
}
}
xhr.send();
Preferisci invece metodi più sicuri e veloci come JSON.parse()
var xhr = new XMLHttpRequest();
xhr.open("GET", "https://api.example.com/data.json", true);
xhr.onreadystatechange = function() {
if (xhr.readyState == 4) {
// JSON.parse does not evaluate the attacker's scripts.
var resp = JSON.parse(xhr.responseText);
}
}
xhr.send();
Utilizza con attenzione gli script di contenuti
Anche se gli script di contenuti vivono in un mondo isolato, non sono immuni agli attacchi:
- Gli script di contenuti sono l'unica parte di un'estensione che interagisce direttamente con la pagina web. Per questo motivo, le pagine web ostili potrebbero manipolare parti del DOM da cui dipende lo script dei contenuti o sfruttare comportamenti standard web sorprendenti, ad esempio gli elementi con nome.
- Per interagire con il DOM delle pagine web, gli script di contenuti devono essere eseguiti nello stesso processo di rendering della pagina web. Questo rende gli script di contenuti vulnerabili a fughe di dati tramite attacchi a canali laterali (ad es. Spectre) e la violazione da parte di un utente malintenzionato se una pagina web dannosa compromette il processo di rendering.
Le operazioni sensibili devono essere eseguite in un processo dedicato, come lo script in background dell'estensione. Evita di esporre accidentalmente i privilegi delle estensioni agli script di contenuti:
- Supponiamo che i messaggi provenienti da uno script di contenuti siano stati creati da un utente malintenzionato (ad es. convalida e sottoponi a sanitizzazione tutti gli input e proteggi i tuoi script da cross-site scripting).
- Supponiamo che i dati inviati allo script dei contenuti possano essere trasmessi alla pagina web. Non inviare dati sensibili (ad es. secret dell'estensione, dati di altre origini web, cronologia di navigazione) agli script di contenuti.
- Limita l'ambito delle azioni con privilegi che possono essere attivate dagli script di contenuti. Non consentire agli script di contenuti di attivare richieste per URL arbitrari o trasmettere argomenti arbitrari alle API di estensione (ad es. non consentire il trasferimento di URL arbitrari all'API
fetch
o all'APIchrome.tabs.create
).
Registra e sanitizza gli input
Proteggi un'estensione da script dannosi limitando i listener solo a ciò che l'estensione si aspetta, convalidando i mittenti dei dati in entrata e sanitizzando tutti gli input.
Un'estensione deve essere registrata per runtime.onRequestExternal
solo se si aspetta la comunicazione da un'estensione o un sito web esterno. Verifica sempre che il mittente
corrisponda a una fonte attendibile.
// The ID of an external extension
const kFriendlyExtensionId = "iamafriendlyextensionhereisdatas";
chrome.runtime.onMessageExternal.addListener(
function(request, sender, sendResponse) {
if (sender.id === kFriendlyExtensionId)
doSomething();
});
Anche i messaggi inviati tramite evento runtime.onMessage dall'estensione stessa devono essere esaminati per verificare che MessageSender non provenga da uno script di contenuti compromesso.
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
if (request.allowedAction)
console.log("This is an allowed action.");
});
Impedisci a un'estensione di eseguire lo script di un utente malintenzionato sanitizzando gli input utente e i dati in entrata, anche dall'estensione stessa e da origini approvate. Evita le API eseguibili.
function sanitizeInput(input) {
return input.replace(/&/g, '&').replace(/</g, '<').replace(/"/g, '"');
}