Vulnerabilidade de overflow de inteiros e sua proteção

O estouro de inteiros é um problema comum na programação. Na maioria das linguagens de programação, os valores inteiros são armazenados em uma memória de comprimento fixo. Os inteiros podem ser divididos em números sem sinal e números com sinal, com a diferença de que o bit mais significativo é usado como bit de sinal para representar positivo ou negativo. Por exemplo, 32 bits de memória podem armazenar inteiros sem sinal de 0 a 4.294.967.295 (uint32), ou inteiros com sinal de -2.147.483.648 a 2.147.483.647 (int32).

Quando o resultado de um cálculo excede o intervalo que pode ser representado pelo tipo inteiro, ocorre um estouro. A maioria das linguagens de programação não verifica esse erro, mas realiza uma simples operação de módulo ou produz um comportamento indefinido. Isso pode levar a resultados inesperados na execução do programa. Em contratos inteligentes de blockchain, especialmente na área de DeFi, cálculos inteiros são muito comuns, portanto, é necessário ter atenção especial às vulnerabilidades de estouro de inteiros.

Definição de overflow de inteiro

A sobrecarga de inteiros divide-se em duas situações: overflow( e underflow).

1. Overflow: O resultado excede o valor máximo do tipo inteiro. Por exemplo, 0xFFFFFFFF de um uint32 mais 1 se tornará 0x00000000.

2. Underflow: o resultado é menor que o valor mínimo do tipo inteiro. Por exemplo, 0 menos 1 em uint32 se torna 0xFFFFFFFF.

Tecnologia de Proteção

Em Rust, podem ser tomadas as seguintes medidas para evitar a sobrecarga de inteiros:

1. Configurar o Cargo.toml para verificar a sobrecarga de inteiros também no modo de release:

toml [profile.release] overflow-checks = true panic = 'abort'

2. Usar a crate uint para suportar inteiros maiores:

ferrugem use uint::construct_uint;

construct_uint! { pub struct U1024(16); }

3. Usar funções matemáticas seguras como checked_*:

ferrugem let result = x.checked_add(y).expect("Overflow na adição");

4. Utilize funções de conversão de tipo como as_u128() para detectar overflow:

ferrugem let amount_u256 = U256::from(u128::MAX) + 1; let amount_u128 = amount_u256.as_u128(); // irá disparar panic

Através destes métodos, podemos prevenir eficazmente vulnerabilidades de overflow de inteiros em contratos inteligentes Rust, aumentando a segurança dos contratos. Ao escrever contratos inteligentes que envolvem cálculos matemáticos, é fundamental tratar as operações inteiras com cuidado, adotando as medidas de proteção adequadas.