Armadilhas no Tauri: 5 configurações de segurança incorretas que vêm ativadas por padrão

Um modelo de segurança só é tão forte quanto suas configurações padrão. O Tauri se apresenta como a alternativa ao Electron que prioriza a segurança na criação de aplicativos desktop. Sua arquitetura divide a confiança entre um back-end em Rust ("Core") e um front-end baseado na web ("Renderer"), com uma camada IPC mediando o acesso.

Em teoria, isso representa uma melhoria significativa em relação ao modelo antigo do Electron, no qual o Node.js é executado no próprio processo do renderer (embora, hoje em dia, o renderer do Electron já venha com isolamento de contexto e sandbox ativados por padrão, de modo que apenas o processo principal tem acesso direto ao Node.js). O Tauri também pode ser mais leve que o Electron e tem a vantagem de oferecer suporte a várias estruturas de back-end que você pode simplesmente integrar ao Tauri para criar um aplicativo desktop funcional.

Ao analisar as opções de configuração do Tauri, identificamos cinco configurações incorretas comuns — algumas delas são padrão ou aparecem em exemplos oficiais — que podem comprometer silenciosamente as garantias de segurança da estrutura.

1. Curinga no protocolo de assets: quando "/**/*" significa o disco inteiro

O protocolo de assets do Tauri permite que o front-end carregue arquivos locais. Ele é útil para renderizar imagens, carregar dados locais ou disponibilizar conteúdo estático. O problema surge quando o escopo é configurado com um curinga como /**/*:

// src-tauri/tauri.conf.json
{
  "security": {
    "assetProtocol": {
      "enable": true,
      "scope": ["/**/*"]
    }
  }
}

Com essa configuração, qualquer JavaScript em qualquer janela do renderer pode chamar fetch("asset://localhost/etc/passwd") e ler arquivos arbitrários acessíveis ao processo do aplicativo. Não é necessário que o usuário faça nada, não há caixa de diálogo de confirmação nem verificação adicional de permissões.

A ameaça não se limita ao seu próprio código. Uma única vulnerabilidade de XSS, uma dependência npm comprometida ou até mesmo um script malicioso injetado por um webview teria acesso de leitura ao sistema de arquivos local. Na prática, isso transforma o renderer em uma ferramenta para exfiltrar arquivos locais.

O que fazer: Restrinja o protocolo de assets aos diretórios específicos de que seu aplicativo realmente precisa. Nunca use /**/* em produção. Se você não precisa do protocolo de assets, desative-o por completo.

2. Escopo de comandos vazio permite tudo

O sistema de permissões do Tauri permite que os desenvolvedores definam escopos de comandos, restringindo as entradas aceitas. Porém, quando não há uma ACL configurada para um comando, o código retorna um CommandScope vazio em vez de negar o acesso.

Isso vai contra a intuição. É razoável que um desenvolvedor espere que um comando não configurado negue todas as operações por padrão (uma postura de "negar por padrão"). Em vez disso, o método matches() em um escopo vazio retorna true para todas as entradas.

// Developer expects this to be restrictive, but it allows everything
fn handle_command(scope: CommandScope<MyArgs>) {
    if scope.matches(&user_input) {
        // This always passes when scope is empty
        execute(user_input);
    }
}

Para implementar de fato o comportamento de negar por padrão, os desenvolvedores precisam verificar manualmente scope.allows().is_empty() e tratar esse caso.

Combinado com a armadilha nº 1, isso significa que um desenvolvedor que não configurou explicitamente os escopos dos comandos pode estar expondo, sem saber, amplo acesso a qualquer script do renderer.

O que fazer: Defina sempre escopos de permissão explícitos para cada comando exposto pelo seu aplicativo. Trate escopos vazios como um problema de segurança. Considere encapsular as verificações de escopo em uma função auxiliar que imponha a regra de negar por padrão.

3. Poluição de protótipo por objetos não congelados

Por padrão, o Tauri não congela o Object.prototype no contexto do renderer. A opção freezePrototype existe, mas seu valor padrão é false.

Isso é importante porque o mecanismo IPC do Tauri funciona por meio de JavaScript. Se um invasor conseguir causar poluição de protótipo (uma classe de ataque bem documentada em JavaScript), poderá sequestrar chamadas IPC modificando os protótipos usados pela ponte do Tauri.

// tauri.conf.json — not enabled by default
{
  "app": {
    "security": {
      "freezePrototype": true
    }
  }
}

A poluição de protótipo já é um risco conhecido em aplicativos web, mas, em um aplicativo desktop com acesso IPC ao sistema local, o impacto aumenta significativamente. Um protótipo poluído poderia redirecionar chamadas IPC, modificar argumentos de comandos ou interceptar respostas.

O que fazer: Defina freezePrototype: true na configuração do Tauri. É uma alteração de uma linha, com impacto mínimo no código legítimo.

4. Recursos de janela com curinga

O sistema de recursos do Tauri permite que os desenvolvedores atribuam permissões a janelas específicas. Mas usar um curinga no identificador da janela concede o recurso a todas as janelas do aplicativo:

{
  "identifier": "my-capability",
  "windows": ["*"],
  "permissions": ["fs:allow-read-text-file"]
}

Esse padrão corresponde a todas as janelas, incluindo as criadas dinamicamente, novas janelas do navegador ou janelas que um script malicioso possa abrir. Se uma janela for comprometida, o invasor não precisa escapar para outras janelas, pois todas já compartilham as mesmas permissões.

Isso foi demonstrado na prática em um aplicativo baseado em Tauri que concedia permissões excessivamente amplas entre janelas, enfraquecendo o modelo de isolamento que os recursos deveriam proporcionar.

O que fazer: Especifique sempre os identificadores das janelas. Revise a configuração dos recursos para garantir que as permissões estejam restritas ao menor conjunto de janelas que realmente precisa delas.

5. Navegação padrão permissiva

Por padrão, o comportamento de navegação do Tauri permite que o webview navegue para qualquer URL. Não há uma lista de permissões integrada. Os desenvolvedores precisam implementar as próprias restrições explícitas de navegação.

Por si só, esse é um risco moderado: um ataque de XSS poderia redirecionar o webview para um site de phishing ou iniciar downloads. Mas, quando combinado com o recurso de janela com curinga (armadilha nº 4) e restrições fracas de origem para IPC, isso se torna um vetor de escalada de privilégios.

Veja como funciona o ataque: o invasor navega com uma janela privilegiada até uma origem que controla e, em seguida, invoca comandos IPC do Tauri nesse contexto. Se o recurso da janela usar "*", a origem do invasor herda todas as permissões atribuídas ao recurso.

O que fazer: Implemente um manipulador de navegação que restrinja as origens permitidas. Permita a navegação somente para os domínios que seu aplicativo precisa carregar explicitamente.

O efeito combinado

Cada um desses problemas está documentado individualmente, e alguns até têm CVEs correspondentes (como CVE-2024-35222, de bypass do controle de acesso IPC, e CVE-2022-39215, de bypass de escopo por meio de links simbólicos). Mas o risco real está na forma como eles se combinam.

Uma única vulnerabilidade de XSS em um aplicativo Tauri com a configuração padrão pode encadear vários problemas: protótipos não congelados para sequestrar o IPC, escopos com curinga para acessar qualquer comando, curingas no protocolo de assets para ler o sistema de arquivos e navegação permissiva para exfiltrar dados para uma origem controlada por um invasor.

Em sua arquitetura, o modelo de segurança do Tauri é semelhante ao do Electron. Mas só a arquitetura não garante um software seguro. O que importa são as configurações padrão e, atualmente, várias configurações padrão do Tauri vão contra as garantias de segurança que a estrutura foi criada para oferecer.

Ações recomendadas

1. Audite seus arquivos tauri.conf.json e de recursos considerando cada armadilha listada acima

2. Defina freezePrototype: true

3. Substitua todos os escopos com curinga (/**/*, *) por caminhos e identificadores de janela explícitos

4. Implemente uma lista de permissões para navegação

5. Adicione escopos explícitos de permissão ou negação a cada comando exposto

6. Use o Snyk para verificar se as dependências Rust e JavaScript do seu aplicativo Tauri têm vulnerabilidades conhecidas

Seus aplicativos desktop estão protegidos contra configurações incorretas encadeadas que podem transformar uma única falha no comprometimento total do sistema? Baixe o whitepaper A crise de segurança de IA no seu ambiente Python para saber como equipes modernas estão protegendo o desenvolvimento baseado em IA em diferentes linguagens e estruturas.