Miri: Seu Detetive Pessoal para Comportamento Indefinido em Rust

Escrevendo em Rust e confiante na segurança do seu código? Claro, já que Rust é famoso pelo seu sistema de tipos e garantias de segurança de memória. Mas e se eu dissesse que mesmo em Rust você pode encontrar Comportamento Indefinido (UB), que pode levar a crashes imprevisíveis, vulnerabilidades, ou simplesmente um comportamento muito estranho do programa? Sim, blocos unsafe são uma ferramenta poderosa que dá incrível flexibilidade e desempenho, mas com isso vem uma grande responsabilidade. É exatamente aqui que o Miri entra em cena — um ajudante indispensável para todo desenvolvedor Rust.

O que é o Miri e por que você precisa dele?

Imagine que você tem um super detetive que pode olhar dentro do seu programa e encontrar todas as armadilhas escondidas que podem levar a comportamento indefinido. O Miri é exatamente esse detetive. É uma ferramenta para detectar Comportamento Indefinido em Rust que funciona como um interpretador para a representação intermediária do Rust (MIR). Ele executa os binários e suites de testes do seu projeto cargo e identifica código unsafe que não atende aos requisitos de segurança do Rust.

Quem precisa disso? Se você trabalha com código unsafe, escreve abstrações de baixo nível, cria bibliotecas que precisam ser o mais confiáveis possível, ou simplesmente quer ter absoluta confiança na sua aplicação Rust, o Miri se tornará seu melhor amigo. Ele ajuda a capturar aqueles erros que o compilador não detectará e que testes regulares não cobrirão, porque podem se manifestar apenas sob condições específicas ou em certas plataformas.

Miri em ação: Que problemas ele encontra?

O Miri não apenas procura erros, ele identifica especificamente tipos concretos de comportamento indefinido que podem minar a estabilidade da sua aplicação. Aqui estão apenas alguns deles:

• Erros de acesso à memória: Este é um clássico. O Miri detectará se você sair dos limites da memória alocada (acesso fora dos limites) ou tentar usar memória depois que ela foi liberada (uso após liberação). Situação familiar quando o programa crasha nos lugares mais inesperados? O Miri ajudará a encontrar a raiz do problema.
• Uso incorreto de dados não inicializados: Tentar ler dados da memória que não foi inicializada é um caminho direto para UB. O Miri mantém um olhar vigilante sobre isso.
• Violações de invariantes de tipo: O Rust monitora rigorosamente os tipos, mas em blocos unsafe você pode violar até invariantes básicas, por exemplo, criar um bool que não é 0 ou 1, ou um enum com um discriminante inválido. O Miri também capturará isso.
• Problemas de alinhamento de memória: Acessar memória com alinhamento insuficiente pode levar a falhas em algumas arquiteturas. O Miri verificará se todos os seus ponteiros estão alinhados corretamente.
• Data races e modelo fraco de memória: Concorrência é difícil. O Miri pode emular alguns efeitos fracos de memória e detectar data races que são extremamente difíceis de reproduzir em hardware real. Isso é especialmente valioso para aplicações multithread.
• Vazamentos de memória: No final da execução do programa, o Miri verificará se há alguma memória alocada que não é mais acessível. Esta é uma ótima maneira de encontrar vazamentos que podem lenta mas seguramente "consumir" os recursos do seu servidor.
• Verificações experimentais de aliasing: O Miri também inclui verificações experimentais para as regras de Stacked Borrows e Tree Borrows, que ajudam a identificar violações mais sutis das regras de aliasing para tipos de referência. Estes são esforços de pesquisa de ponta que já estão ajudando a tornar o Rust ainda mais seguro.

Como o Miri faz isso: Um mergulho profundo no interpretador

Ao contrário de analisadores estáticos, o Miri não apenas escaneia seu código. Ele executa em sua própria "sandbox" — como um interpretador para a representação intermediária do Rust (MIR). Isso permite observar o comportamento do programa em tempo real e identificar problemas que só se manifestam durante a execução.

Execução determinística: Por padrão, o Miri garante execução totalmente determinística. Isso significa que se você executar o programa com os mesmos dados de entrada, o resultado será sempre idêntico. Como isso é alcançado? O Miri substitui muitas APIs do sistema (por exemplo, geradores de números aleatórios, variáveis de ambiente, relógios) por suas próprias implementações "falsas". Isso é criticamente importante para reproduzir e depurar bugs que poderiam se manifestar aleatoriamente.

Interpretação cruzada: Curiosamente, o Miri pode executar seu código para diferentes plataformas-alvo mesmo se seu sistema host for diferente. Por exemplo, você pode executar testes no Windows, mas o Miri os interpretará como se estivessem rodando no Linux (--target x86_64-unknown-linux-gnu). Isso é especialmente útil para testar código dependente de plataforma, por exemplo, para verificar a correção de manipulações de bytes em sistemas little-endian e big-endian.

Começando com o Miri: Mais fácil do que parece

Integrar o Miri ao seu fluxo de trabalho é bastante simples, especialmente se você já usa rustup e cargo.

Instalação

Para instalar o Miri você precisará de uma versão nightly do Rust. Simplesmente execute:

rustup +nightly component add miri

Executando testes e binários

Após a instalação você pode executar seus projetos através do Miri usando comandos familiares cargo:

• Para executar todos os testes do projeto através do Miri: cargo miri test
• Se você tem um projeto binário, execute-o através do Miri: cargo miri run

Na primeira execução, o Miri realizará configuração adicional e instalará as dependências necessárias, pedindo sua confirmação.

A propósito, cargo miri run/test suporta os mesmos flags que o cargo run/test regular. Por exemplo, cargo miri test filter executará apenas testes contendo filter no nome.

Recursos avançados com flags do Miri

Você pode passar flags especiais do Miri através da variável de ambiente MIRIFLAGS. Por exemplo, para desabilitar o isolamento do sistema host (e obter acesso a APIs reais do sistema, mas perder determinismo):

RUST_BACKTRACE=1 MIRIFLAGS="-Zmiri-disable-isolation" cargo miri test

Ou, para testar vários cenários de comportamento não-determinístico (por exemplo, diferentes entrelaçamentos de threads ou endereços de alocação):

MIRIFLAGS="-Zmiri-many-seeds=0..16" cargo miri test

Esta é uma funcionalidade muito poderosa para identificar bugs difíceis de capturar que só se manifestam sob certas condições.

Integração com CI/CD

O Miri é ótimo para verificações automatizadas em CI. Aqui está um exemplo de como configurar um job para GitHub Actions:

  miri:
    name: "Miri"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Miri
        run: |
          rustup toolchain install nightly --component miri
          rustup override set nightly
          cargo miri setup
      - name: Test with Miri
        run: cargo miri test

Ignorando testes incompatíveis com o Miri

Às vezes seu código pode usar APIs que o Miri ainda não suporta (por exemplo, operações de rede). Nesses casos, você pode simplesmente ignorar esses testes para o Miri:

#[test]
#[cfg_attr(miri, ignore)]
fn does_not_work_on_miri() {
    // Ваш код, который Miri не поддерживает
}

O Miri já está salvando o mundo (e seu código)

A coisa mais impressionante sobre o Miri é sua eficácia comprovada. Ele já descobriu muitos bugs reais na biblioteca padrão do Rust e em crates populares. Entre eles estavam erros relacionados a acesso à memória não inicializada em VecDeque, alinhamento incorreto em Vec, vazamentos de memória em BTreeMap, e até data races em canais std::mpsc. Esta não é apenas uma ferramenta acadêmica, mas um ajudante testado em batalha que é ativamente usado para melhorar a confiabilidade do ecossistema Rust.

Conclusões: O Miri vale a pena tentar?

Com certeza! O Miri não é uma bala de prata, e não capturará todas as possíveis violações da especificação do Rust (porque tal especificação unificada essencialmente não existe). No entanto, é uma ferramenta indispensável para melhorar a confiabilidade do código Rust, especialmente em seções unsafe e ao trabalhar com concorrência.

Se você leva a qualidade do seu código Rust a sério, quer minimizar riscos relacionados a Comportamento Indefinido, e quer ter confiança na estabilidade das suas aplicações, o Miri deve estar no seu arsenal. Ele ajudará você a encontrar e corrigir aqueles bugs insidiosos que podem estar escondidos profundamente no seu código, antes que se tornem um problema para seus usuários. Experimente o Miri, e você ficará surpreso com quantas coisas interessantes ele pode encontrar no seu código aparentemente perfeito!