Integer Overflow: O que E, Exemplos

Como Inteiros Sao Armazenados na Memoria

Computadores armazenam numeros em bits. Um inteiro de 8 bits sem sinal pode representar de 0 a 255. Um inteiro de 16 bits sem sinal vai de 0 a 65.535. Um inteiro de 32 bits sem sinal chega ate 4.294.967.295. O ponto critico e que esse limite nao e negociavel: quando o valor tenta ultrapassar o maximo, o tipo nao cresce automaticamente. Ele volta para zero, ou para o valor minimo negativo no caso de inteiros com sinal.

Em inteiros com sinal de 8 bits, o maior valor e 127. Se voce adicionar 1 a 127, o resultado e -128. Esse comportamento e chamado de wrap-around, e e matematicamente consistente na aritmetica modular que os processadores usam. O problema e que nenhum programador que escreveu aquele calculo esperava que o resultado fosse negativo.

Esse mecanismo existe ha decadas e ainda aparece em vulnerabilidades de seguranca, falhas de sistemas criticos e bugs em jogos. A representacao binaria de numeros nao mudou. O que muda e o quanto os programadores modernos pensam nisso ao escolher tipos e fazer calculos.

Integer Overflow em C: O Caso Mais Perigoso

Em C, overflow de inteiros com sinal e tecnicamente comportamento indefinido segundo o padrao da linguagem. Isso significa que o compilador pode fazer qualquer coisa, incluindo otimizacoes que assumem que overflow nunca vai acontecer. Na pratica, a maioria dos compiladores modernos produz o wrap-around esperado, mas isso nao e garantido e pode mudar com flags de otimizacao diferentes.

Um exemplo classico em C: se voce tem um int com valor 2147483647 (o maior int de 32 bits com sinal) e adiciona 1, o resultado depende do compilador e das flags de otimizacao. Com -O2 no GCC, o compilador pode assumir que esse overflow nunca acontece e remover verificacoes de loop que dependiam dessa suposicao, criando loops infinitos ou comportamentos inesperados que nao existiam sem otimizacao.

Para detectar overflow em C com seguranca, a opcao mais moderna e usar as funcoes de aritmetica segura disponíveis em compiladores recentes, como __builtin_add_overflow no GCC e Clang. Essas funcoes retornam true se o overflow aconteceu, sem comportamento indefinido.

Integer Overflow em JavaScript: O Problema dos 53 Bits

JavaScript nao tem tipos inteiros nativos. Todos os numeros sao doubles de 64 bits segundo o padrao IEEE 754. Isso parece resolver o problema de overflow de inteiros, mas cria uma armadilha diferente: doubles de 64 bits so representam inteiros com precisao exata ate 2^53 - 1, que e o Number.MAX_SAFE_INTEGER com valor 9.007.199.254.740.991.

Acima desse limite, operacoes aritmeticas comecam a produzir resultados errados sem nenhum aviso. Por exemplo, Number.MAX_SAFE_INTEGER + 1 e igual a Number.MAX_SAFE_INTEGER + 2 em JavaScript: ambos resultam em 9007199254740992. Isso e particularmente perigoso quando voce trabalha com IDs de banco de dados grandes, timestamps em microssegundos ou calculos financeiros.

A solucao moderna em JavaScript e o tipo BigInt, disponível desde 2020 em todos os navegadores modernos e Node.js. Com BigInt, voce pode fazer calculos com inteiros arbitrariamente grandes sem perda de precisao. O custo e performance: operacoes com BigInt sao significativamente mais lentas do que operacoes com numeros normais, entao use apenas quando necessario.

Integer Overflow em Python: Quando Nao Ha Overflow

Python 3 nao tem overflow em inteiros. O tipo int do Python cresce automaticamente conforme necessario, usando alocacao dinamica de memoria. Voce pode calcular 2 elevado a 10.000 sem nenhum problema, o resultado e um numero com mais de 3.000 digitos armazenado corretamente. Isso e uma das razoes pelas quais Python e popular para criptografia e matematica de precisao arbitraria.

Mas Python tem armadilhas proprias com pontos flutuantes. O tipo float do Python e um double IEEE 754 de 64 bits, com os mesmos limites de precisao. Alem disso, quando voce usa arrays do NumPy ou dados binarios com struct, os tipos numericos voltam a ter tamanhos fixos. Um array numpy de dtype int8 vai ter overflow silencioso exatamente como em C.

Um erro comum em Python e misturar o int nativo do Python com arrays NumPy de tipo fixo sem converter explicitamente. O calculo parece correto porque voce esta trabalhando com ints Python, mas quando o resultado vai para um array int16 ou int32, o overflow acontece na atribuicao. Verificar o dtype dos arrays NumPy antes de operacoes criticas e uma pratica que salva muito tempo de debug.

O Ariane 5 e a Licao que Todo Dev Deveria Conhecer

O caso mais famoso de integer overflow na historia e a explosao do foguete Ariane 5 em 1996. O codigo do sistema de navegacao inercial tinha sido copiado do Ariane 4 e funcionava perfeitamente no foguete anterior. O problema era uma variavel de velocidade horizontal armazenada como float de 64 bits sendo convertida para um inteiro de 16 bits. No Ariane 4, essa variavel nunca ultrapassava o limite do int16. No Ariane 5, o foguete era mais rapido e a variavel excedeu o limite pouco depois do lancamento.

Quando o overflow aconteceu, o sistema de navegacao lancou uma excecao de operand error. Mas em vez de usar um valor de fallback ou desligar apenas aquele modulo, o sistema transmitiu os dados de diagnostico de erro diretamente para o computador de voo como se fossem dados de posicao validos. O computador de voo recebeu o que pareciam ser dados de navegacao indicando uma mudanca brusca de trajetoria e ordenou ao foguete que corrigisse a rota. A estrutura nao aguentou o estresse e o foguete se autodestruiu aos 37 segundos.

O artigo completo sobre esse desastre esta em A Historia Nao Contada do Desastre do Ariane 5, com a analise tecnica detalhada do relatorio oficial da ESA e as licoes de engenharia de sistemas criticos que ele gerou.

Como Detectar e Prevenir Overflow na Pratica

Por que Codigo Herdado e Mais Vulneravel?

Codigo escrito para um contexto especifico carrega suposicoes embutidas sobre os limites dos valores com que trabalha. O codigo do Ariane 5 foi escrito assumindo os limites de velocidade do Ariane 4. Quando o contexto mudou, as suposicoes nao foram revisadas. Esse padrao se repete em sistemas legados em toda a industria: um sistema bancario original assumia transacoes em moedas de valor menor, um sistema de log assumia que nunca teria mais de 32.767 registros por dia, um contador de IDs assumia que nunca passaria de 65.535 usuarios.

A dificuldade com codigo herdado e que as suposicoes raramente estao documentadas. Elas estavam na cabeca do dev original, talvez em um comentario que foi removido em um refactor, talvez em um documento que ninguem mais sabe onde esta. Quando o sistema cresce alem das suposicoes originais, o overflow acontece em producao, sem aviso previo, as vezes anos depois do codigo ter sido escrito.

Integer overflow e um problema real em 2026 ou e coisa do passado?

E muito real. O relatorio anual do CWE (Common Weakness Enumeration) consistentemente lista integer overflow e conversao de inteiros como uma das classes de vulnerabilidade mais exploradas. Em 2024 e 2025, bugs de overflow foram a causa raiz de vulnerabilidades criticas em kernels de sistemas operacionais, bibliotecas de processamento de imagem e sistemas de controle industrial. A diferenca e que em linguagens modernas como Rust, o overflow e detectado em modo debug e configuravel em modo release. Mas a maioria dos sistemas criticos ainda roda em C, C++ e linguagens sem essas protecoes automaticas.

BigInt no JavaScript resolve todos os problemas de precisao numerica?

Resolve o problema de precisao de inteiros, mas nao resolve todos os problemas numericos. BigInt nao pode ser misturado com Number em operacoes aritmeticas sem conversao explicita, o que cria fricao no codigo. Alem disso, BigInt nao existe no contexto de TypedArrays e WebAssembly sem conversao, entao em codigo de performance critica voce ainda vai lidar com tipos de tamanho fixo. Para calculos financeiros, a solucao mais robusta continua sendo usar bibliotecas especializadas como decimal.js que implementam aritmetica decimal de precisao arbitraria, evitando tanto overflow quanto erros de representacao de ponto flutuante.