Esta página foi traduzida pela API Cloud Translation.

Proteja-se

As extensões têm acesso a privilégios especiais no navegador, o que as torna um alvo atraente para invasores. Se uma extensão for comprometida, todos os usuários dessa extensão ficarão vulneráveis a para impedir intrusões maliciosas e indesejadas. Mantenha uma extensão segura e os usuários protegidos incorporando essas práticas.

Proteger contas de desenvolvedor

O upload e a atualização do código da extensão são feitos pelas Contas do Google. Se os desenvolvedores contas são um invasor poderia enviar códigos maliciosos diretamente para todos os usuários. Proteger estas contas por Criar especificamente contas de desenvolvedor e ativar a autenticação de dois fatores , de preferência usando uma chave de segurança .

Mantenha os grupos seletivos

Se você estiver usando a publicação em grupo, mantenha o grupo restrito a desenvolvedores confiáveis. Não aceitar solicitações de participação de pessoas desconhecidas.

Nunca usar HTTP

Ao solicitar ou enviar dados, evite uma conexão HTTP. Suponha que todas as conexões HTTP ter observadores ou conter modificações. Recomendamos sempre o uso de HTTPS, já que o de segurança que contornam a maioria dos ataques "man-in-the-middle".

Solicitar permissões mínimas

O navegador Chrome limita o acesso de uma extensão aos privilégios que foram explicitamente solicitados em o manifesto. As extensões devem minimizar suas permissões registrando apenas APIs e dos sites de que dependem. O código arbitrário deve ser reduzido ao mínimo.

A limitação de privilégios de uma extensão limita o que um invasor em potencial pode explorar.

XMLHttpRequest de origem cruzada

Uma extensão só pode usar XMLHttpRequest para receber recursos de si mesma e de domínios especificado nas permissões.

{
  "name": "Very Secure Extension",
  "version": "1.0",
  "description": "Example of a Secure Extension",
  "permissions": [
    "/*",
    "https://*.google.com/"
  ],
  "manifest_version": 2
}

Esta extensão solicita acesso a qualquer conteúdo em developer.chrome.com e em subdomínios do Google por listando "/*" e "https://*google.com/" nas permissões. Se o extensão fosse comprometida, ela só teria permissão para interagir com sites que cumpram o padrão de correspondência. O invasor não poderia acessar o "https://user_bank_info.com" ou interagem com "https://malicious_website.com".

Limitar campos do manifesto

A inclusão de registros desnecessários no manifesto cria vulnerabilidades e torna uma extensão mais visível. Limite os campos do manifesto aos que a extensão depende e forneça campos específicos registro.

Conectável externamente

Use o campo externally_connectable para declarar quais extensões e páginas da Web externas compartilhará informações com ela. Restringir com quem a extensão pode se conectar externamente fontes confiáveis.

{
  "name": "Super Safe Extension",
  "externally_connectable": {
    "ids": [
      "iamafriendlyextensionhereisdatas"
    ],
    "matches": [
      "/*",
      "https://*google.com/"
    ],
    "accepts_tls_channel_id": false
  },
  ...
}

Recursos acessíveis pela Web

Tornar os recursos acessíveis pela Web, de acordo com a web_accessible_resources, fará uma que pode ser detectada por sites e invasores.

{
  ...
  "web_accessible_resources": [
    "images/*.png",
    "style/secure_extension.css",
    "script/secure_extension.js"
  ],
  ...
}

Quanto mais recursos acessíveis na Web estiverem disponíveis, mais caminhos um invasor em potencial poderá explorar. Manter o mínimo possível desses arquivos.

Incluir uma política de segurança de conteúdo explícita

Inclua uma Política de Segurança de Conteúdo para a extensão no manifesto a fim de evitar a interação entre sites. ataques de scripting. Se a extensão só carregar recursos de si mesma, registre o seguinte:

{
  "name": "Very Secure Extension",
  "version": "1.0",
  "description": "Example of a Secure Extension",
  "content_security_policy": "default-src 'self'"
  "manifest_version": 2
}

Se a extensão precisar incluir scripts de hosts específicos, eles poderão ser incluídos:

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

Evitar APIs executáveis

As APIs que executam código precisam ser substituídas por alternativas mais seguras.

document.write() e innerHTML

Embora possa ser mais simples criar elementos HTML dinamicamente com document.write() e innerHTML, ela sai da extensão e das páginas da web das quais a extensão depende, abertas a invasores que inserem scripts maliciosos. Em vez disso, crie nós do DOM manualmente e use innerText para inserir conteúdo dinâmico.

function constructDOM() {
  let newTitle = document.createElement('h1');
  newTitle.innerText = host;
  document.appendChild(newTitle);
}

eval()

Evite usar eval() sempre que possível para evitar ataques, já que o eval() executará qualquer código transmitido. o que pode ser malicioso.

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

Em vez disso, prefira métodos mais seguros e rápidos, como 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();

Use scripts de conteúdo com cuidado

Embora os scripts de conteúdo estejam em um mundo isolado, eles não estão imunes a ataques:

Os scripts de conteúdo são a única parte de uma extensão que interage diretamente com a página da Web. Por causa disso, páginas da Web hostis podem manipular partes do DOM do qual o script de conteúdo depende, ou explorar comportamentos padrão surpreendentes da Web, como itens nomeados.
Para interagir com o DOM de páginas da Web, os scripts de conteúdo precisam ser executados no mesmo processo do renderizador que da página da Web. Isso deixa os scripts de conteúdo vulneráveis ao vazamento de dados por ataques de canal lateral. (por exemplo, Spectre) e de ser invadido por um invasor se uma página da Web maliciosa for comprometida o processo do renderizador.

O trabalho confidencial deve ser realizado em um processo dedicado, como o segundo plano da extensão script. Evite expor acidentalmente privilégios de extensão a scripts de conteúdo:

Suponha que as mensagens de um script de conteúdo possam ter sido criadas por um invasor (por exemplo, valide e limpe todas as entradas e proteja seus scripts contra scripts entre sites.
Suponha que qualquer dado enviado ao script de conteúdo possa vazar para a página da Web. Não envie dados sensíveis (por exemplo, segredos da extensão, dados de outras origens da Web, histórico de navegação) ao conteúdo scripts.
Limite o escopo das ações privilegiadas que podem ser acionadas por scripts de conteúdo. Não permitir scripts de conteúdo para acionar solicitações a URLs arbitrários ou passar argumentos arbitrários para de extensão (por exemplo, não permitem a transmissão de URLs arbitrários para fetch ou API chrome.tabs.create).

Registrar e limpar entradas

Proteger uma extensão contra scripts maliciosos limitando os listeners apenas ao que é a extensão esperar, validar os remetentes de dados recebidos e limpar todas as entradas.

Uma extensão só deve ser registrada em runtime.onRequestExternal se estiver esperando a comunicação de um site ou extensão externo. Sempre confirme se o remetente corresponde a em uma fonte confiável.

// The ID of an external extension
const kFriendlyExtensionId = "iamafriendlyextensionhereisdatas";

chrome.runtime.onMessageExternal.addListener(
  function(request, sender, sendResponse) {
    if (sender.id === kFriendlyExtensionId)
      doSomething();
});

Até mesmo as mensagens via evento runtime.onMessage da própria extensão devem ser examinadas para verificar se confira se o MessageSender não é de um script de conteúdo comprometido.

chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
  if (request.allowedAction)
    console.log("This is an allowed action.");
});

evitar que uma extensão execute o script de um invasor limpando as entradas do usuário e as dados, mesmo da própria extensão e de fontes aprovadas. Evite APIs executáveis.

function sanitizeInput(input) {
    return input.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;');
}