Les extensions ont accès à des privilèges spéciaux dans le navigateur, ce qui en fait une cible attrayante pour les pirates informatiques. Si une extension est compromise, tous ses utilisateurs deviennent vulnérables aux intrusions malveillantes et indésirables. Pour sécuriser une extension et protéger ses utilisateurs, suivez ces pratiques.
Protéger les comptes de développeur
Le code d'extension est importé et mis à jour via des comptes Google. Si les comptes des développeurs sont compromis, un pirate informatique peut envoyer du code malveillant directement à tous les utilisateurs. Protégez ces comptes en activant l'authentification à deux facteurs , de préférence avec une clé de sécurité.
Utiliser des rôles de membre appropriés
Si votre éditeur compte plusieurs membres, assurez-vous que le rôle accordé à chaque utilisateur est approprié.
Ne jamais utiliser HTTP
Lorsque vous demandez ou envoyez des données, évitez une connexion HTTP. Considérez que toutes les connexions HTTP seront écoutées ou modifiées. Il est toujours préférable d'utiliser HTTPS, car il dispose d'une sécurité intégrée qui contourne la plupart des attaques MITM ("man in the middle").
Demander des autorisations minimales
Le navigateur Chrome limite l'accès d'une extension aux privilèges qui ont été explicitement demandés dans le fichier manifeste. Les extensions doivent minimiser leurs autorisations en n'enregistrant que les API et les sites Web dont elles dépendent.
Limiter les privilèges d'une extension limite ce qu'un pirate informatique potentiel peut exploiter.
Cross-origin fetch()
Une extension ne peut utiliser fetch() et XMLHttpRequest() que pour obtenir des ressources à partir de l'
extension et des domaines spécifiés dans les autorisations. Notez que les appels aux deux sont interceptés par
le gestionnaire de récupération dans le service worker.
{
"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
}
Dans l'exemple ci-dessus, cette extension demande l'accès à tout ce qui se trouve sur developer.chrome.com et les sous-domaines de Google en
listant "https://developer.chrome.com/*" et "https://*.google.com/*" dans les autorisations. Si l'
extension était compromise, elle n'aurait toujours l'autorisation d'interagir qu'avec les sites Web qui correspondent
au modèle. Le pirate informatique n'aurait qu'une capacité limitée à accéder à "https://user_bank_info.com" ou à
interagir avec "https://malicious_website.com".
Limiter les champs du fichier manifeste
L'inclusion de clés et d'autorisations inutiles dans le fichier manifeste crée des failles et rend une extension plus visible. Limitez les champs du fichier manifeste à ceux dont l'extension dépend.
Connectable en externe
Utilisez le champ "externally_connectable" pour déclarer les extensions et les pages Web externes avec lesquelles l'
extension échangera des informations. Limitez les sources externes auxquelles l'extension peut se connecter à des sources fiables.
{
"name": "Super Safe Extension",
"externally_connectable": {
"ids": [
"iamafriendlyextensionhereisdatas"
],
"matches": [
"https://developer.chrome.com/*",
"https://*.google.com/*"
],
"accepts_tls_channel_id": false
},
...
}
Ressources accessibles sur le Web
Si vous rendez des ressources accessibles sur le Web sous "web_accessible_resources", les sites Web et les pirates informatiques pourront détecter une
extension.
{
...
"web_accessible_resources": [
{
"resources": [ "test1.png", "test2.png" ],
"matches": [ "https://web-accessible-resources-1.glitch.me/*" ]
}
]
...
}
Plus il y a de ressources accessibles sur le Web, plus un pirate informatique potentiel peut exploiter de voies. Réduisez ces fichiers au minimum.
Inclure une règle de sécurité du contenu explicite
Incluez une règle de sécurité du contenu pour l'extension dans le fichier manifeste afin d'empêcher les attaques de script intersite. Si l'extension ne charge que des ressources à partir d'elle-même, enregistrez les éléments suivants :
{
"name": "Very Secure Extension",
"version": "1.0",
"description": "Example of a Secure Extension",
"content_security_policy": {
"extension_pages": "default-src 'self'"
},
"manifest_version": 3
}
Si l'extension doit utiliser l'assemblage Web ou augmenter les restrictions sur les pages en bac à sable , vous pouvez les ajouter :
{
"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
}
Éviter document.write() et innerHTML
Bien qu'il soit plus simple de créer dynamiquement des éléments HTML avec document.write() et innerHTML, cela permet aux pirates informatiques d'insérer des scripts malveillants dans l'extension et les pages Web dont elle dépend. Créez plutôt manuellement des nœuds DOM et utilisez innerText pour insérer du contenu dynamique.
function constructDOM() {
let newTitle = document.createElement('h1');
newTitle.innerText = host;
document.appendChild(newTitle);
}
Utiliser les scripts de contenu avec précaution
Bien que les scripts de contenu vivent dans un monde isolé, ils ne sont pas à l'abri des attaques :
- Les scripts de contenu sont la seule partie d'une extension qui interagit directement avec la page Web. Pour cette raison, les pages Web hostiles peuvent manipuler des parties du DOM dont dépend le script de contenu, ou exploiter un comportement surprenant des normes Web, comme les éléments nommés.
- Pour interagir avec le DOM des pages Web, les scripts de contenu doivent s'exécuter dans le même processus de rendu que la page Web. Cela rend les scripts de contenu vulnérables à la fuite de données via des attaques par canal auxiliaire (par exemple, Spectre) et à la prise de contrôle par un pirate informatique si une page Web malveillante compromet le processus de rendu.
Les opérations utilisant des données sensibles (telles que les informations privées d'un utilisateur) ou les API Chrome ayant accès aux fonctions du navigateur doivent être effectuées dans le service worker des extensions. Évitez d'exposer accidentellement les privilèges d'extension aux scripts de contenu :
- Considérez que les messages d'un script de contenu ont peut-être été créés par un pirate informatique (par exemple, validez et nettoyez toutes les entrées, et protégez vos scripts contre les scripts intersites).
- Considérez que toutes les données envoyées au script de contenu peuvent être divulguées à la page Web. N'envoyez pas de données sensibles (par exemple, des secrets de l'extension, des données provenant d'autres origines Web, l'historique de navigation) aux scripts de contenu.
- Limitez la portée des actions privilégiées qui peuvent être déclenchées par les scripts de contenu. N'autorisez pas les
scripts de contenu à déclencher des requêtes vers des URL arbitraires ni à transmettre des arguments arbitraires aux
API d'extension (par exemple, n'autorisez pas la transmission d'URL arbitraires aux méthodes
fetch()ouchrome.tabs.create()).
Enregistrer et nettoyer les entrées
Protégez une extension contre les scripts malveillants en limitant les écouteurs à ce que l'extension attend, en validant les expéditeurs des données entrantes et en nettoyant toutes les entrées.
Une extension ne doit s'enregistrer que pour runtime.onMessageExternal si elle attend
une communication d'un site Web ou d'une extension externe. Vérifiez toujours que l'expéditeur correspond à une source fiable.
// The ID of an external extension
const kFriendlyExtensionId = "iamafriendlyextensionhereisdatas";
chrome.runtime.onMessageExternal.addListener(
function(request, sender, sendResponse) {
if (sender.id === kFriendlyExtensionId)
doSomething();
});
Même les messages provenant de l'extension elle-même via l'événement runtime.onMessage doivent être examinés attentivement pour s'assurer que MessageSender ne provient pas d'un script de contenu compromis.
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
if (request.allowedAction)
console.log("This is an allowed action.");
});