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.

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.

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
