Passo 5: Definindo as Regras de Segurança do Firebase

Você pode ter o código JavaScript mais bonito do mundo no seu site, mas se as regras de segurança do seu Firebase Realtime Database estiverem incorretas, seu banco de dados estará vulnerável! As regras são o seu único "backend de segurança" e são cruciais para proteger seus dados.

1. Acessando as Regras de Segurança

1. No Firebase Console, navegue até o seu projeto.
2. No menu lateral esquerdo, na seção "Build" (Construir), clique em "Realtime Database".
3. No topo da página do Realtime Database, clique na aba "Regras".

Você verá um editor de texto com as regras atuais do seu banco de dados (provavelmente aquelas do "Modo de teste").

2. Entendendo e Aplicando as Regras

As regras do Firebase são escritas em JSON e definem quem pode ler (`.read`) e escrever (`.write`) em cada parte do seu banco de dados, além de permitir validações de dados (`.validate`).

Vou utilizar as regras que uso para esse chat, pois elas são um excelente exemplo de proteção e já estão criadas.

Apague o conteúdo atual no editor de regras e cole o seguinte código JSON:

{
  "rules": {
    "comentarios": {
      ".read": true,
      "$comentario": {
        ".write": "
          newData.hasChildren(['nome', 'mensagem', 'timestamp']) &&
          newData.child('nome').isString() &&
          newData.child('mensagem').isString() &&
          newData.child('timestamp').isNumber()
        ",
        "nome": {
          ".validate": "
            newData.isString() &&
            newData.val().length <= 30 &&
            !newData.val().toLowerCase().matches(/^\\s*lei\\s*arcaica\\s*$/) &&
            !newData.val().toLowerCase().matches(/^\\s*lei\\s*arcalca\\s*$/) &&
            !newData.val().toLowerCase().matches(/^\\s*lei\\s*arc[ai]ca\\s*$/) &&
            !newData.val().toLowerCase().matches(/^\\s*lei\\s*arc[a\\s]*ca.*\\d+.*$/) &&
            !newData.val().matches(/<.*?>/) &&
            !newData.val().matches(/[^\\u0020-\\u007e\\w]/)
          "
        },
        "mensagem": {
          ".validate": "
            newData.isString() &&
            newData.val().length <= 500 &&
            !newData.val().matches(/<.*?>/)
          "
        },
        "timestamp": {
          ".validate": "newData.isNumber()"
        }
      }
    },
    "$other": {
      ".read": false,
      ".write": false
    }
  }
}
            

Depois de colar o código, clique em "Publicar" para salvar as alterações. O Firebase aplicará essas regras ao seu banco de dados.

Análise Detalhada das Regras: Seu "Backend" de Segurança

Vamos entender o que cada parte dessas regras faz para proteger o chat:

• "comentarios": { ".read": true, ... }: A linha `".read": true` permite que qualquer pessoa leia as mensagens no nó `comentarios`. Isso é essencial para um chat público onde todos precisam ver o histórico de conversas.

• "$comentario": { ".write": "...", ... }: Esta seção define quem pode escrever (enviar) novas mensagens. O `$comentario` é uma variável que representa cada nova mensagem que é adicionada. A condição de escrita é bem rigorosa:

  • `newData.hasChildren(['nome', 'mensagem', 'timestamp'])`: Garante que cada nova mensagem sempre tenha os campos `nome`, `mensagem` e `timestamp`. Se um campo estiver faltando, a escrita é negada.
  • `newData.child('nome').isString() && ...`: Verifica se os campos `nome` e `mensagem` são textos (strings) e se `timestamp` é um número.

• "nome": { ".validate": "...", ... }: Aqui, o Firebase valida o conteúdo do campo `nome`:

  • `newData.val().length <= 30`: Limita o nome a um máximo de 30 caracteres. Isso evita nomes excessivamente longos que poderiam ser usados para spam ou outros abusos.
  • `!newData.val().toLowerCase().matches(...)`: Essas linhas bloqueiam variações do meu próprio nick (`leiarcaica`) para evitar que outras pessoas se passem por mim.
  • `!newData.val().matches(/<.*?>/)`: Essa é crucial contra XSS! Ela impede que qualquer tag HTML (como `<script>`) seja inserida no nome.
  • `!newData.val().matches(/[^\\u0020-\\u007e\\w]/)`: Restringe o nome a caracteres alfanuméricos, underscore (`_`) e espaços básicos. Isso ajuda a prevenir a injeção de caracteres especiais maliciosos.

• "mensagem": { ".validate": "...", ... }: Similar ao nome, aqui as mensagens são validadas:

  • `newData.val().length <= 500`: Limita a mensagem a 500 caracteres.
  • `!newData.val().matches(/<.*?>/)`: Também crucial contra XSS! Impede tags HTML na mensagem.

• "$other": { ".read": false, ".write": false }: Esta é uma regra de segurança geral muito importante. Ela garante que nenhuma outra parte do seu banco de dados (além do nó `comentarios`) possa ser lida ou escrita por ninguém. É uma forma de "fechar todas as portas" que não estão explicitamente abertas.

3. Testando Suas Regras (Opcional)

O Firebase Console tem um Simulador de Regras na mesma aba "Regras". Você pode usá-lo para testar se suas regras estão funcionando como esperado. Tente simular uma escrita com um nome muito longo ou com tags HTML e veja se ela é negada.

Com as regras de segurança aplicadas, seu chat está muito mais protegido contra entradas indesejadas e abusos básicos. No próximo passo, falarei sobre como lidar com as limitações e problemas comuns que podem surgir.