Principais Conclusões sobre Isolamento de Navegador no Linux

  • O desafio: Perfis nativos de navegador separam dados, mas não processos nem tráfego de rede. Isso facilita que as plataformas que você usa interliguem as contas.
  • Usando Firejail: O Firejail adiciona isolamento em nível de processo via namespaces e seccomp. Namespaces controlam o que o processo pode ver; seccomp controla o que ele pode fazer. Juntos, eles contêm o navegador de forma mais rígida do que apenas executá-lo com uma pasta de perfil separada.
  • Usando contêineres: Contêineres são o único método que também isola a pilha de rede. Eles dão a cada instância do navegador sua própria camada de rede separada, ou seja, sua própria interface de rede, roteamento IP e resolução de DNS.
  • O papel de um proxy: Perfis separados por si só não mudam seu endereço IP, daí a necessidade de usar um proxy confiável. Cada perfil deve ter seu próprio proxy, configurado por instância, e não em todo o sistema.
  • Interligação de perfis: Uma impressão digital correspondente ainda pode interligar perfis, mesmo com cookies limpos. Características do navegador e do dispositivo podem identificar um perfil independentemente dos dados armazenados.
  • Gerenciamento de credenciais e extensões: Eles devem ser gerenciados por perfil, não compartilhados. Reutilizar logins ou complementos entre perfis cria um vínculo entre eles, independentemente do isolamento técnico.
  • Gerenciamento do ciclo de vida: Apague um perfil quando um projeto terminar, em vez de reutilizá-lo. Reutilizar o perfil corre o risco de levar cookies, cache ou credenciais para um novo contexto não relacionado.

O Que É um Ambiente de Navegador Isolado

Um ambiente de navegador isolado significa que uma identidade de navegador, incluindo seus dados de perfil, cookies, cache e extensões, é mantida em seu próprio armazenamento, separada de todas as outras identidades na máquina.

No Linux, essa separação vem em três níveis de força:

  • Um perfil nativo de navegador isola os dados em si.
  • Uma sandbox Firejail adiciona isolamento de processo além disso.
  • Um contêiner vai ainda mais longe, isolando o sistema de arquivos, a árvore de processos e a pilha de rede.

Os desenvolvedores usam esses níveis para manter os dados limpos e separados entre diferentes projetos ou clientes, escolhendo o nível de isolamento que corresponde à sensibilidade da separação necessária.

Como mostrado nas imagens acima, cada nível adiciona uma fronteira de isolamento que o anterior não possui: desde a separação apenas de dados, até o isolamento de processos dentro de uma rede compartilhada, até o isolamento completo de sistema de arquivos, processos e rede em um contêiner.

O Que Vaza Entre Perfis Não Isolados

Sem isolamento adequado, os perfis de navegador podem compartilhar dados e sinais entre si de várias maneiras, minando a separação que deveriam fornecer. Isso pode incluir:

  • Cookies e localStorage compartilhados permitem que sites leiam dados salvos por outro perfil.
  • Um IP compartilhado liga todos os perfis à mesma origem de rede.
  • Uma impressão digital idêntica do navegador (fontes, tamanho da tela, detalhes de hardware) pode identificar perfis como relacionados, mesmo com armazenamento limpo.
  • Sessões salvas no chaveiro do sistema podem conectar automaticamente um perfil a uma conta destinada a outro.

Na captura de tela acima, ambos os perfis foram executados no teste de Canvas Fingerprinting do BrowserLeaks e retornaram a assinatura idêntica, apesar de serem perfis separados e não isolados. Mesma GPU, mesmo SO, mesma saída de renderização. Isso é suficiente para as plataformas os vincularem como um único visitante, sem precisar de um único cookie.

O Que o Isolamento de Perfil Não Pode Fazer

O isolamento de perfil às vezes é tratado como se fornecesse muita segurança e privacidade que obviamente não fornece. Aqui está o que o isolamento de perfil não pode fazer:

  • Não criptografa o tráfego.
  • Não muda sua impressão digital.
  • Não esconde seu endereço IP.

Para alcançar a separação total para projetos ou dados de clientes, você pode precisar combinar o isolamento de perfil com gerenciamento de impressão digital e um proxy por perfil.

Três Níveis de Isolamento de Navegador no Linux, Comparados

Os três níveis estão resumidos acima e detalhados nos métodos a seguir, do mais leve ao mais rígido.

Pré-requisitos

Aqui está o que você precisará para implementar os métodos de isolamento acima:

  • Um ambiente de desktop Linux: Necessário para executar e visualizar as GUIs do navegador descritas ao longo do texto.
  • Direitos de sudo: Necessários para instalar Firejail e Podman via comandos do gerenciador de pacotes no Método 2 e no Método 3.
  • Firefox e/ou Chromium: Usaremos para implementar o método 1, perfis nativos de navegador, que é o mais simples dos três.
  • Firejail e Podman: Necessários apenas para implementar o Método 2 (Firejail) e o Método 3 (contêineres). Não são necessários se você estiver fazendo apenas perfis nativos.
  • Versões testadas: Ubuntu 24.04 LTS, Firefox ESR 128, Chromium 126, Firejail 0.9.72, Podman 5.0.

Agora, vamos explorar os 3 métodos para executar com segurança múltiplos perfis de navegador no Linux.

Método 1: Perfis Nativos de Navegador

Esta é a opção mais fácil e rápida, sem necessidade de software extra. No entanto, ela separa apenas dados, não processos.

Siga estes três passos para implementar perfis no Firefox.

Passo 1: Criar Perfis Separados do Firefox com o Gerenciador de Perfis

Execute firefox -P no terminal, ou abra o Firefox e vá para about:profiles, para criar e nomear um novo perfil. Para executar dois perfis ao mesmo tempo, inicie o segundo executando firefox -no-remote -P "ProfileName".

A flag -no-remote é necessária em builds onde o Firefox usa o modo de instância única por padrão e, caso contrário, apenas abriria uma nova janela no perfil já em execução, em vez de iniciar um separado.

Na captura de tela acima, o Gerenciador de Perfis do Firefox, aberto com o comando firefox -P, é onde novos perfis são criados e nomeados antes de iniciar cada um independentemente.

Passo 2: Executar Chromium com um --user-data-dir Dedicado

Crie um perfil no Chromium executando o seguinte comando no terminal:

chromium-browser --user-data-dir=~/profiles/client-a

Isso diz ao Chromium para armazenar todos os dados dessa sessão, incluindo cookies, extensões, cache, logins salvos e histórico de navegação, na pasta ~/profiles/client-a em vez do local padrão.

Cada vez que você iniciar o Chromium com um caminho --user-data-dir diferente, você obtém um perfil separado e isolado.

Se você iniciar o Chromium sem a flag, ele volta ao perfil padrão.

Na captura de tela acima, chrome://version confirma que a flag --user-data-dir realmente teve efeito. O Caminho do Perfil lê /home/tom-sankara/~/profiles/client-a/Default, correspondendo ao diretório passado na inicialização, o que prova que os dados desta sessão estão sendo gravados na pasta isolada, não no perfil padrão do Chromium.

Passo 3: Dividir Cookies Ainda Mais com os Contêineres Multi-Account do Firefox

Instale o complemento Firefox Multi-Account Containers e crie um contêiner separado para cada projeto, fixando os sites relevantes a esse contêiner.

Isso pode ser útil quando um perfil separado completo é exagero; por exemplo, testar várias contas logadas no mesmo site ou manter alguns projetos paralelos sem contaminação cruzada de cookies, tudo dentro de um único perfil. Os contêineres ainda compartilham um perfil e um IP, então eles adicionam conveniência, não isolamento completo.

Como mostrado nas capturas de tela acima, ambas as abas de contêiner carregam x.com sem sessão compartilhada. Como os contêineres compartilham um processo de navegador e um IP, isso apenas prova a separação de cookies e armazenamento, não o isolamento de rede.

Método 2: Sandbox para Cada Perfil com Firejail

Firejail executa um navegador dentro de um ambiente restrito, isolando-o do resto do sistema. Isso eleva a separação apenas de dados dos perfis nativos para a separação completa de processos, usando namespaces para controlar o que o processo em sandbox pode ver e seccomp para restringir o que ele pode fazer.

Vamos explorar os passos para criar sandboxes de perfis usando Firejail.

Passo 1: Instalar Firejail na Sua Distribuição

Para Debian/Ubuntu:

sudo apt install firejail

Fedora:

sudo dnf install firejail

Arch:

sudo pacman -S firejail

Para o propósito deste guia, usaremos Ubuntu.

Passo 2: Dar a Cada Perfil um Diretório Home Privado

Execute este comando para dar ao perfil seu próprio diretório home privado:

firejail --noprofile --private=~/profiles/client-a /home/tom-sankara/firefox/firefox

Substitua tom-sankara pelo seu próprio nome de usuário; as capturas de tela neste guia foram feitas em uma máquina de teste, então seu terminal mostrará um nome diferente. Isso é esperado e não afeta nada. Isso remapeia tudo o que a sandbox vê como $HOME para ~/profiles/client-a; o navegador não tem visibilidade do seu diretório home real, apenas do que está dentro dessa pasta.

A nova janela do Firefox que se abre confirma isso: sem marcadores importados, sem logins salvos, sem histórico existente, apenas os widgets padrão de nova aba. Isso é o isolamento funcionando como pretendido, não um bug.

Passo 3: Iniciar a Sandbox e Confirmar que Está Ativa

Com a sandbox ainda em execução, abra um segundo terminal e execute:

firejail --list
firejail --tree

Como mostrado na captura de tela acima, o comando firejail --list confirma uma sandbox ativa ligada ao comando exato --private= que a iniciou. E o comando firejail --tree mostra o processo completo aninhado sob ela; o binário do Firefox, seus processos de conteúdo e seu auxiliar de crash todos rodando como filhos do wrapper firejail, em vez de diretamente no host. Sua própria saída mostrará o nome de usuário da sua máquina no lugar do mostrado.

Esta é a prova real de que o navegador está em sandbox, não apenas que uma janela foi aberta.

Método 3: Executar Cada Perfil em um Contêiner Podman ou Docker

Contêineres empacotam um navegador e suas dependências em um ambiente totalmente isolado, com seu próprio sistema de arquivos, espaço de processos e pilha de rede. Este é o mais forte dos três métodos e o único que também separa a rede.

Vamos explorar os passos para implementar este método.

Passo 1: Baixar ou Construir uma Imagem de Contêiner do Navegador

Baixe a imagem do contêiner do Firefox usando Docker ou Podman:

podman pull docker.io/jlesage/firefox

Este comando baixa uma imagem de contêiner do Firefox pré-construída, então você não precisa construir uma você mesmo. Se você quiser uma configuração personalizada, pode construir a partir de um Containerfile mínimo que instala o navegador e suas dependências. Usuários de Docker podem executar o equivalente docker pull docker.io/jlesage/firefox.

Passo 2: Iniciar um Contêiner por Perfil de Desenvolvedor

Execute este comando no seu terminal:

podman run -d \
--name firefox-client-a \
--shm-size=2gb \
-p 5800:5800 \
-v client-a-profile:/config \
jlesage/firefox

Cada flag serve a um propósito específico:

  • --name firefox-client-a dá ao contêiner um nome legível em vez de uma string aleatória, para que comandos posteriores, como stop, logs e remove, sejam fáceis de direcionar.
  • --shm-size=2gb aloca memória compartilhada suficiente para o navegador rodar suavemente, pois o padrão do contêiner costuma ser pequeno demais.
  • -p 5800:5800 mapeia a interface web noVNC embutida do contêiner para uma porta no seu host. Diferente de um navegador instalado localmente, esta imagem não tem acesso direto ao seu display, então ela serve o Firefox como um stream que você vê em uma aba regular do navegador.
  • -v client-a-profile:/config monta um volume nomeado para que os dados daquele perfil persistam entre reinicializações.

Após executar o comando, abra http://localhost:5800 em qualquer navegador no seu host. O Firefox carrega dentro da própria página, renderizado através do noVNC.

Repita com um nome, porta e volume diferentes para criar um contêiner separado para cada perfil de desenvolvedor:

podman run -d \
--name firefox-client-b \
--shm-size=2gb \
-p 5801:5800 \
-v client-b-profile:/config \
jlesage/firefox

Acesse esta segunda instância em http://localhost:5801.

Execute o comando podman ps para confirmar que ambos os contêineres estão ativos, cada um com seu próprio mapeamento de porta e volume; isso prova que os dois perfis estão rodando em contêineres totalmente separados, em vez de compartilhar um.

Como mostrado acima, podman ps confirma ambos os contêineres rodando independentemente, cada um com seu próprio mapeamento de porta e volume nomeado, provando que as duas instâncias do Firefox estão totalmente separadas uma da outra.

Passo 3: Persistir Dados do Perfil Entre Sessões

Volumes nomeados (como client-a-profile e client-b-profile acima) são gerenciados automaticamente pelo Podman e persistem entre reinicializações do contêiner sem configuração extra. Execute o comando podman volume ls para confirmar que eles existem.

Para fazer backup de um perfil, encontre seu caminho real com podman volume inspect client-a-profile e copie o conteúdo para outro lugar. Para redefinir um para um estado limpo, pare o contêiner, remova o volume e deixe o Podman recriá-lo na próxima execução. Esse procedimento remove o volume e os dados contidos nele:

podman stop firefox-client-a && podman rm firefox-client-a
podman volume rm client-a-profile
podman run -d --name firefox-client-a --shm-size=2gb -p 5800:5800 -v client-a-profile:/config jlesage/firefox

Dar a Cada Perfil Seu Próprio Endereço IP

Mesmo com isolamento perfeito de dados, processos e rede, três perfis que todos saem pelo mesmo IP doméstico ainda são facilmente vinculáveis; qualquer site pode ver que eles vêm da mesma rede ou dispositivo.

Isso importa principalmente para gerenciamento de contas, onde as plataformas procuram ativamente por IPs compartilhados para sinalizar contas relacionadas.

Você pode corrigir isso dando a cada perfil um endereço IP diferente usando um provedor de proxy comercial.

Escolher um Provedor de Proxy

Para fins de demonstração, usamos o serviço ProxyWing para esta configuração. O ProxyWing oferece endpoints de proxy de datacenter, residenciais, móveis e ISP, com autenticação por login/senha ou lista de IPs permitidos e segmentação por país; um endpoint por perfil. Isso se encaixa naturalmente na etapa de proxy abaixo, sem infraestrutura extra.

Como sempre, faça sua própria pesquisa e compare preços antes de se comprometer com qualquer provedor.

Passo 1: Configurar o Proxy por Instância do Navegador, Não em Todo o Sistema

Configure o proxy no nível do navegador. No Firefox, vá para Configurações > Privacidade e Segurança > Conexão e Segurança de Software > Configurar proxy e insira os detalhes do proxy daquele perfil.

Você será solicitado a inserir as credenciais de autenticação na primeira vez que tentar se conectar através deste proxy. Como isso é armazenado por perfil, outros perfis do Firefox não são afetados.

No Chromium, não há equivalente de GUI por perfil, então passe o proxy diretamente na inicialização com --proxy-server=http://user:pass@host:port, que se aplica apenas àquela instância.

Passo 2: Verificar o IP, DNS e WebRTC de Cada Perfil

Configurar um proxy não garante que ele esteja realmente funcionando. Configurações incorretas ou vazamentos ainda podem expor seu IP real de rede ou dispositivo. Abra uma ferramenta de verificação de IP e um teste de vazamento WebRTC, como browserleaks.com/webrtc, em cada perfil e compare os resultados lado a lado. A captura de tela abaixo mostra o proxy roteando para a França para um dos perfis.

Uma configuração correta mostra um IP distinto por perfil, correspondendo à localização do proxy, com a resolução de DNS também roteando através do proxy em vez do seu ISP, e nenhum vazamento WebRTC revelando seu IP local ou público real.

Automatizar a Inicialização de Perfis com um Script e Entradas de Desktop

Um pequeno script de shell recebe um nome de perfil e inicia o navegador, a sandbox e o proxy corretos juntos em um único comando. Combiná-lo com um arquivo .desktop transforma cada perfil em seu próprio ícone de inicializador no menu de aplicativos.

Boas Práticas de Segurança para Múltiplos Perfis de Desenvolvedor

  • Nunca reutilize um perfil para dois clientes.
  • Mantenha credenciais em um cofre separado por perfil.
  • Desative a sincronização do navegador.
  • Audite extensões por perfil.
  • Apague o perfil quando o projeto terminar.
  • Confirme que o proxy está ativo antes de fazer login.
  • Nunca copie cookies ou dados de sessão entre perfis.

Problemas Comuns e Como Corrigi-los

1. A Segunda Janela do Navegador Abre no Primeiro Perfil

Ambos os navegadores usam o modo de instância única por padrão, então um segundo lançamento apenas abre uma janela no perfil em execução. Para corrigir:

  • Para Firefox, adicione a flag -no-remote para forçar uma nova instância genuína.
  • Para Chromium, certifique-se de que cada inicialização use um caminho --user-data-dir distinto, pois reutilizar o mesmo caminho, ou omiti-lo, é o que causa o fallback.

2. Sites Ainda Vinculam Seus Perfis a Uma Pessoa

Para resolver este problema, verifique nesta ordem:

  • Um IP de saída compartilhado: corrija com um proxy único por perfil.
  • Uma impressão digital idêntica: corrija com configurações de randomização de impressão digital.
  • Fuso horário e localidade correspondentes: ajuste para corresponder à região do proxy.
  • Uma conta de sincronização conectada: desative a sincronização em outros perfis.

3. O Navegador em Sandbox ou Contêiner Não Inicia

Algumas causas comuns incluem:

  • Permissões ausentes do socket de exibição.
  • Um /dev/shm muito pequeno: aumente com --shm-size.
  • Negativas do SELinux na montagem: ajuste o contexto ou adicione :z.
  • Uma regra do Firejail bloqueando o caminho: edite o perfil.

Observe a saída de erro; ela geralmente aponta qual das causas se aplica.

Qual Configuração Você Deve Escolher

A configuração que você escolher depende em grande parte dos seus requisitos. Aqui está um critério simples que pode facilitar sua escolha:

  • Uso casual de múltiplas contas: perfis nativos são suficientes.
  • Separação de clientes: use Firejail, pois adiciona proteção real sem muito overhead.
  • Testes que não devem tocar o host: para tais projetos, contêineres são a única solução confiável.

Perguntas Frequentes (FAQ)

P: Posso executar dois perfis do Firefox ao mesmo tempo no Linux?

R: Sim. Após iniciar o primeiro, inicie o segundo com -no-remote -P "ProfileName" se sua build usar o modo de instância única por padrão.

P: O Firejail é suficiente para manter os perfis do navegador separados?

R: Ele isola sistemas de arquivos e processos, não redes. Você ainda precisa de um proxy separado por perfil. Um proxy permite alocar um endereço IP único para cada perfil.

P: Preciso de um endereço IP diferente para cada perfil de navegador?

R: Para a maioria dos casos casuais, você pode usar o mesmo IP. No entanto, para tarefas como gerenciamento de contas ou testes geográficos, você precisará de um endereço IP diferente para cada perfil.

P: Qual é a diferença entre um contêiner do Firefox e um perfil do Firefox?

R: Um contêiner divide cookies dentro de um perfil. Um perfil é uma identidade totalmente separada, com seu próprio armazenamento.

P: Executar um navegador no Docker o torna mais lento?

R: Há algum overhead do runtime e do socket de exibição. No entanto, a diferença de desempenho geralmente é pequena em hardware moderno.

P: É permitido usar várias contas de desenvolvedor de uma única máquina?

R: Geralmente sim, desde que esteja em conformidade com os termos de serviço de cada plataforma.