Unsafe Rust oferece mais controle sobre a memória. Aprenda a trabalhar com Rust inseguro e entenda os riscos inerentes associados ao seu uso.
As garantias de segurança da memória são um dos pontos de venda do Rust; no entanto, Rust não é imune a bugs e vulnerabilidades. Como o verificador de empréstimo do Rust impõe o modelo de propriedade, há uma pequena compensação no tempo de compilação durante as verificações de segurança.
O Rust fornece funcionalidade para ignorar as verificações de segurança em um recurso chamado “Unsafe Rust”, que permite evitar essas verificações de segurança para fins de desempenho. O Unsafe Rust é uma ferramenta poderosa para escrever software de sistemas eficiente e de baixo nível com Rust.
Compreendendo a ferrugem insegura
Unsafe Rust é um conjunto de recursos que você pode usar para contornar as garantias de segurança do Rust em troca de maior controle sobre a memória. Os recursos inseguros do Rust incluem ponteiros brutos, funções inseguras e características inseguras.
O objetivo do Rust inseguro é fornecer aos desenvolvedores a capacidade de escrever código de sistema de baixo nível sem sacrificar o desempenho. Você pode acessar e manipular recursos de memória diretamente e aumentar o desempenho de seu aplicativo com Rust inseguro.
Unsafe Rust é particularmente útil no desenvolvimento de sistemas operacionais, programação de rede e desenvolvimento de jogos, onde o desempenho é crítico. Nesses contextos, você precisará de um controle refinado sobre o layout da memória do programa e o comportamento do código. O Unsafe Rust permite que você consiga isso fornecendo abstrações de baixo nível para implementar algoritmos complexos e estruturas de dados.
Trabalhando com ferrugem insegura
Blocos inseguros fornecem a funcionalidade para usar recursos inseguros do Rust. Você usará o inseguro palavra-chave para definir blocos inseguros contendo código Rust válido.
Veja como você pode usar um bloco inseguro para acesso direto à memória para modificação de valor:
fnprincipal() {
deixarmudo x = 10;inseguro {
deixar bruto = &mudo x como *mudoi32;
*crua = 20;
}
println!("x agora é {}", x);
}
O x variável é um inteiro mutável. No inseguro bloco, o ponteiro bruto para x atribui um novo valor a x. O código no inseguro o bloco é válido, mas não seguro e não estava em um bloco inseguro; o programa trava.
Além disso, você pode definir funções inseguras adicionando o inseguro palavra-chave antes do fn palavra-chave em suas declarações de função.
insegurofnperform_unsafe_operation() {
// Seu código inseguro aqui
}
Você precisará de um bloco não seguro para chamar funções não seguras em outras partes do seu programa.
fnprincipal() {
inseguro {
perform_unsafe_operation();
}
}
Funções de marcação com o inseguro palavra-chave não significa que a função é inerentemente perigosa. Indica que a função contém código que requer cuidado extra no uso.
Os riscos associados ao uso de ferrugem insegura
O uso indevido de Rust inseguro pode levar a erros de memória, corridas de dados e outras vulnerabilidades de segurança. Portanto, é crucial entender os riscos ao seguir as melhores práticas associadas ao Rust inseguro para escrever código seguro e de alto desempenho.
O principal risco associado ao Rust inseguro é o potencial de bugs relacionados à memória que podem levar a travamentos, vulnerabilidades de segurança e comportamentos de código indefinidos.
Erros de memória ocorrem quando um programa tenta acessar a memória de forma anormal; o programa eventualmente falha ou se comporta de forma imprevisível.
As corridas de dados ocorrem quando dois ou mais threads de programa acessam a mesma parte da memória simultaneamente e, ao mesmo tempo, pelo menos um dos threads está modificando o valor na memória, fazendo com que o programa se comporte inesperadamente.
Você pode acionar estouros de buffer usando Rust inseguro de maneira inadequada. Estouros de buffer ocorrem quando um programa grava dados além do final de um buffer. Estouros de buffer podem fazer com que o programa trave ou permitir que invasores executem código arbitrário.
Outra vulnerabilidade é use-after-free (UAF), que ocorre quando um programa acessa a memória após a desalocação de valor. O UAF pode fazer com que o programa se comporte de forma imprevisível e potencialmente introduzir vulnerabilidades de segurança.
Devido a essas vulnerabilidades, ao trabalhar com Rust inseguro, é essencial entender a propriedade de Rust e como funciona o modelo de empréstimo no Rust seguindo as melhores práticas.
O gerenciamento de memória do Rust é flexível
O modelo de propriedade do Rust gerencia a memória automaticamente, reduzindo o risco de bugs relacionados à memória. O empréstimo permite que várias variáveis acessem os mesmos recursos de memória sem conflitos simultaneamente.
O gerenciamento de memória do Rust fornece a flexibilidade, segurança e desempenho necessários para o desenvolvimento de software moderno, tornando o Rust uma ferramenta poderosa para escrever código eficiente e confiável.
