1

Por que validadores comuns deixam passar ataques invisíveis em Unicode (e como resolvi isso em Rust sem macros e sem dependências)

Grande parte dos validadores de formulário e schema na web verifica apenas tamanho de string, formato de e-mail ou expressões regulares básicas. O problema é que, na borda de entrada da aplicação, diversos vetores passam completamente despercebidos por esse tipo de checagem:

  1. Caracteres invisíveis e Trojan Source (U+202E): espaços de largura zero (U+200B, U+FEFF), códigos de controle não imprimíveis e caracteres de inversão bidirecional (bidi overrides) conseguem alterar a exibição visual de nomes de arquivo, logs ou identificadores sem mudar o valor real armazenado.
  2. Assinaturas clássicas de XSS e SQLi: payloads com pseudo-protocolos de execução em URLs, handlers de eventos inline em HTML, tags perigosas embutidas, além de tautologias booleanas, comentários de linha/bloco e comandos SQL empilhados destrutivos.
  3. Validação de padrões brasileiros atualizados: como o novo CNPJ alfanumérico (IN RFB 2229/2024, que entra em vigor em 2026), além de CPF e algoritmo de Luhn.

(Importante: validação na borda de entrada é uma camada adicional de defesa em profundidade — ela não substitui prepared statements no banco de dados nem output encoding / CSP na camada de visualização.)

A abordagem sem macros e sem dependências (catfive v0.3)

Ao desenvolver a catfive (biblioteca open-source em Rust, licença MIT), optei por uma arquitetura desacoplada de macros e com zero dependências externas por padrão (apenas std).

Na versão 0.3.0, removi utilitários redundantes (como UUID e base64/hex) e integrei a inspeção de segurança diretamente na validação padrão de strings (catfive::string()). Assim, o desenvolvedor não precisa lembrar de encadear métodos manuais de sanitização em cada campo:

use catfive::{schema, string, Validator};

struct User {
    username: String,
    cnpj: String,
}

fn main() {
    let user_schema = schema::<User>()
        .field("username", |u| &u.username, string().min(3).max(20))
        .field("cnpj", |u| &u.cnpj, string().spek("[CNPJ]")); // aceita numérico e alfanumérico

    // Entrada legítima passa normalmente:
    let valid = User {
        username: "kreivetech".to_string(),
        cnpj: "12.ABC.345/01DE-35".to_string(),
    };
    assert!(user_schema.validate(&valid).is_ok());

    // Caractere bidirecional oculto (Trojan Source) é barrado automaticamente:
    let malicious = User {
        username: "admin\u{202E}txt".to_string(),
        cnpj: "12.ABC.345/01DE-35".to_string(),
    };
    assert!(user_schema.validate(&malicious).is_err());
}

O código-fonte está disponível no GitHub e publicado no crates.io.

Como vocês costumam equilibrar rigidez vs. falsos positivos na validação de entrada (por exemplo, ao lidar com campos de texto livre que podem conter traços duplos ou palavras-chave SQL legitimamente)?

Carregando publicação patrocinada...