Código / CDG.009Explicado

Segurança de memória: por que o Android passou a escrever código novo em Rust

Falhas de memória já foram 76% das vulnerabilidades do Android. Entenda o que é segurança de memória e por que mudar só o código novo trouxe o maior efeito.

Durante décadas, uma categoria de falha respondeu pela maior parte das vulnerabilidades graves em software: erros no uso da memória. Por exemplo, ler além do fim de uma lista, usar um espaço que já foi liberado, escrever onde não devia. A segurança de memória trata de impedir esses erros, e o caso do Android mostra que a mudança não exige reescrever tudo. Em 2019, falhas de memória eram 76% das vulnerabilidades do sistema. Em 2024, eram 24%.

Neste explicado, você vai entender o que são essas falhas, por que algumas linguagens as evitam e qual foi a estratégia que produziu essa queda.

O que é segurança de memória

Todo programa guarda dados na memória do computador. Em linguagens como C e C++, quem programa controla diretamente onde os dados ficam e quando o espaço é liberado. No entanto, esse controle dá desempenho, mas também abre espaço para erros que o compilador não impede.

Um exemplo clássico: um programa reserva espaço para dez itens e, por um descuido, escreve o décimo primeiro. Assim, o dado vai parar numa área que pertencia a outra coisa. Por isso, em muitos casos, um atacante consegue explorar esse comportamento para executar código próprio.

Linguagens com segurança de memória, como Rust, Kotlin, Java e Python, impedem esses erros por desenho. Algumas fazem isso gerenciando a memória automaticamente; o Rust faz isso com regras verificadas na compilação, sem perder o desempenho de baixo nível.

Comparação entre linguagens sem e com segurança de memória: em C e C++ quem programa gerencia a memória e erros como estouro de buffer e uso após liberação passam pelo compilador; em Rust, Kotlin e Java as regras da linguagem ou o gerenciamento automático impedem essas falhas antes de o programa rodar.
A diferença não está na habilidade de quem programa, e sim no que a linguagem permite.

A segurança de memória no Android

Em setembro de 2024, a equipe de segurança do Google publicou os resultados da estratégia no Google Security Blog. Segundo o texto, a participação das falhas de memória nas vulnerabilidades do Android caiu de 76% em 2019 para 24% em 2024, bem abaixo da média de 70% citada para a indústria.

Ainda assim, o detalhe mais interessante é como isso aconteceu. O Google não reescreveu o sistema inteiro. Em vez disso, passou a priorizar linguagens com segurança de memória, como Rust e Kotlin, para o código novo, a partir de 2019. Para o código antigo, a aposta foi em fazer as partes novas conversarem com segurança com as antigas.

Por que mudar só o código novo melhora a segurança de memória

A explicação vem de uma observação do próprio relatório: vulnerabilidades têm uma espécie de meia-vida. Ou seja, a maior parte das falhas aparece em código novo ou recém-modificado. Por isso, à medida que um trecho envelhece e é testado, ele fica mais seguro.

Então, se o código novo para de introduzir falhas de memória, a proporção total dessas falhas cai com o tempo, mesmo que o código antigo continue lá. É um raciocínio útil para qualquer equipe: mudar a regra para o que entra costuma render mais do que tentar consertar tudo o que já existe.

Linha do tempo da estratégia do Android: em 2019 falhas de memória eram 76% das vulnerabilidades e o código novo passou a priorizar Rust e Kotlin; o código antigo continuou em uso com interoperabilidade segura; em 2024 a participação caiu para 24%.
Dados do Google Security Blog (setembro de 2024).

O que isso significa para quem não trabalha no Android

Você talvez não escreva C++ no dia a dia. Mesmo assim, a lição vale em três níveis:

  • Na escolha de ferramentas. Afinal, bibliotecas que processam dados vindos de fora, como imagens e arquivos compactados, são alvos frequentes. Preferir versões escritas em linguagens seguras reduz a superfície de ataque. Um exemplo recente: o decodificador de JPEG XL que voltou ao Chromium foi escrito em Rust justamente por essa preocupação.
  • Na estratégia de migração. Afinal, reescrever um sistema inteiro é caro e arriscado. Por isso, definir que tudo o que é novo segue uma regra melhor costuma ser o caminho viável.
  • Na revisão de código gerado por IA. Modelos também cometem erros de memória quando escrevem em linguagens que permitem esses erros. Assim, a linguagem certa funciona como uma revisão automática a mais.

Segurança por desenho, não por atenção

A principal ideia por trás da segurança de memória é tirar o peso das costas de quem programa. Em vez de depender de atenção perfeita em cada linha, o sistema torna certos erros impossíveis. Afinal, pessoas cansam, e revisões deixam passar detalhes.

Além disso, esse princípio vale para muito além da memória. Como discutimos em automatizar um processo ruim só faz o erro andar mais rápido, um bom sistema não depende de ninguém acertar tudo sempre. Em vez disso, ele dificulta o erro desde o começo.

/ Conexões

Próximas conexões

Autor

Gledson Dias

Ver todos os artigos

Sistemativo / Brief

Gostou dessa ideia?

A cada duas semanas, ideias, ferramentas, referências e movimentos que valem alguns minutos da sua atenção.

Brief (formulário compacto)

Você poderá sair da lista quando quiser. Sem spam.