CWE-1335 Base Rascunho

Incorrect Bitwise Shift of Integer

This vulnerability occurs when a program attempts to shift an integer's bits by an invalid amount—either a negative number or a value equal to or greater than the integer's bit width (e.g., shifting…

Definição

What is CWE-1335?

This vulnerability occurs when a program attempts to shift an integer's bits by an invalid amount—either a negative number or a value equal to or greater than the integer's bit width (e.g., shifting a 32-bit integer by 32 or more places). This leads to unpredictable and platform-dependent results.
Shifting bits by a negative count is considered undefined behavior in languages like C and C++. Compilers and interpreters typically don't validate this at runtime, leaving the actual operation to be handled by the underlying hardware. Different CPU architectures may produce varying results—such as shifting in the opposite direction, yielding zero, or even causing a crash—which breaks code portability and introduces subtle bugs. Similarly, an overshift (shifting beyond the bit width) also produces undefined or implementation-defined results. Some languages or compilers might mask the shift count, wrap the value, or return zero, but you cannot rely on consistent behavior. This ambiguity makes the code's outcome architecture- and compiler-dependent, creating security risks when the shifted value is used for calculations, memory offsets, or access controls.
Impacto no mundo real

Real-world CVEs caused by CWE-1335

  • CVE-2009-4307

    An unexpected large value in the ext4 filesystem causes an overshift condition resulting in a divide by zero.

  • CVE-2012-2100

    An unexpected large value in the ext4 filesystem causes an overshift condition resulting in a divide by zero - fix of CVE-2009-4307.

  • CVE-2020-8835

    An overshift in a kernel allowed out of bounds reads and writes resulting in a root takeover.

  • CVE-2015-1607

    Program is not properly handling signed bitwise left-shifts causing an overlapping memcpy memory range error.

  • CVE-2016-9842

    Compression function improperly executes a signed left shift of a negative integer.

  • CVE-2018-18445

    Some kernels improperly handle right shifts of 32 bit numbers in a 64 bit register.

  • CVE-2013-4206

    Putty has an incorrectly sized shift value resulting in an overshift.

  • CVE-2018-20788

    LED driver overshifts under certain conditions resulting in a DoS.

Como os atacantes a exploram

Trajeto do atacante passo a passo

  1. 1

    A negative shift amount for an x86 or x86_64 shift instruction will produce the number of bits to be shifted by taking a 2's-complement of the shift amount and effectively masking that amount to the lowest 6 bits for a 64 bit shift instruction.

  2. 2

    The example above ends up with a shift amount of -5. The hexadecimal value is FFFFFFFFFFFFFFFD which, when bits above the 6th bit are masked off, the shift amount becomes a binary shift value of 111101 which is 61 decimal. A shift of 61 produces a very different result than -5. The previous example is a very simple version of the following code which is probably more realistic of what happens in a real system.

  3. 3

    Note that the good example not only checks for negative shifts and disallows them, but it also checks for over-shifts. No bit operation is done if the shift is out of bounds. Depending on the program, perhaps an error message should be logged.

Exemplo de código vulnerável

Vulnerable C

A negative shift amount for an x86 or x86_64 shift instruction will produce the number of bits to be shifted by taking a 2's-complement of the shift amount and effectively masking that amount to the lowest 6 bits for a 64 bit shift instruction.

Vulnerável C 
unsigned int r = 1 << -5;
Exemplo de código seguro

Secure C

Seguro C 
int choose_bit(int reg_bit, int bit_number_from_elsewhere) 
 {

```
   if (NEED_TO_SHIFT)
   {
  	 reg_bit -= bit_number_from_elsewhere;
   }
   return reg_bit;
 }
 unsigned int handle_io_register(unsigned int *r)
 {
   int the_bit_number = choose_bit(5, 10);
   if ((the_bit_number > 0) && (the_bit_number < 63))
   {
  	 unsigned int the_bit = 1 << the_bit_number;
  	 *r |= the_bit;
   }
   return the_bit;
 }
What changed: the unsafe sink is replaced (or the input is validated/escaped) so the same payload no longer triggers the weakness.
Lista de verificação de prevenção

How to prevent CWE-1335

  • Implementation Implicitly or explicitly add checks and mitigation for negative or over-shift values.
Sinais de deteção

How to detect CWE-1335

SAST High

Executar análise estática (SAST) na base de código à procura do padrão inseguro no fluxo de dados.

DAST Moderate

Executar testes dinâmicos de segurança de aplicações (DAST) contra o endpoint em execução.

Runtime Moderate

Monitorizar os registos em tempo de execução para traços de exceção invulgares, input malformado ou tentativas de contornar a autorização.

Code review Moderate

Revisão de código: sinalizar qualquer novo código que trate input desta superfície sem usar os ajudantes validados do framework.

Correção automática do Plexicus

O Plexicus deteta automaticamente o CWE-1335 e abre um PR de correção em menos de 60 segundos.

O Codex Remedium analisa cada commit, identifica esta fraqueza exata e entrega um pull request pronto para revisão com o patch. Sem tickets. Sem transferências.

Obter uma demonstração Experimente o Plexicus gratuitamente
Perguntas frequentes

Frequently asked questions

O que é o CWE-1335?

This vulnerability occurs when a program attempts to shift an integer's bits by an invalid amount—either a negative number or a value equal to or greater than the integer's bit width (e.g., shifting a 32-bit integer by 32 or more places). This leads to unpredictable and platform-dependent results.

Qual a gravidade do CWE-1335?

A MITRE não publicou uma classificação de probabilidade de exploração para esta fraqueza. Trate-a como impacto médio até o seu modelo de ameaças provar o contrário.

Que linguagens ou plataformas são afetadas pelo CWE-1335?

MITRE lists the following affected platforms: C, C++, C#, Java, JavaScript, Not OS-Specific, Not Technology-Specific.

Como posso prevenir o CWE-1335?

Implicitly or explicitly add checks and mitigation for negative or over-shift values.

Como é que o Plexicus deteta e corrige o CWE-1335?

O motor SAST do Plexicus correlaciona a assinatura de fluxo de dados do CWE-1335 em cada commit. Quando é encontrada uma correspondência, o nosso agente Codex Remedium abre um PR de correção com o código corrigido, testes e um resumo de uma linha para o revisor.

Onde posso saber mais sobre o CWE-1335?

A MITRE publica a definição canónica em https://cwe.mitre.org/data/definitions/1335.html. Pode também consultar a documentação da OWASP e do NIST para orientações adjacentes.

Fraquezas relacionadas

Weaknesses related to CWE-1335

CWE-682 Pai

Incorrect Calculation

This vulnerability occurs when software performs a calculation that produces wrong or unexpected results, which are then used to make…

CWE-128 Irmão

Wrap-around Error

A wrap-around error happens when a variable exceeds the maximum value its data type can hold, causing it to unexpectedly reset to a very…

CWE-131 Irmão

Incorrect Calculation of Buffer Size

This vulnerability occurs when a program miscalculates the amount of memory needed for a buffer, potentially leading to a buffer overflow…

CWE-1339 Irmão

Insufficient Precision or Accuracy of a Real Number

This vulnerability occurs when a program uses a data type or algorithm that cannot accurately represent or calculate the fractional part…

CWE-135 Irmão

Incorrect Calculation of Multi-Byte String Length

This vulnerability occurs when software incorrectly measures the length of strings containing multi-byte or wide characters, leading to…

CWE-190 Irmão

Integer Overflow or Wraparound

Integer overflow or wraparound occurs when a calculation produces a numeric result that exceeds the maximum value a variable can hold.…

CWE-191 Irmão

Integer Underflow (Wrap or Wraparound)

Integer underflow occurs when a subtraction operation results in a value smaller than the data type's minimum limit, causing the value to…

CWE-193 Irmão

Off-by-one Error

An off-by-one error occurs when a program incorrectly calculates a boundary, such as a loop counter or array index, by being one unit too…

CWE-369 Irmão

Divide By Zero

A divide-by-zero error occurs when software attempts to perform a division operation where the denominator is zero.

Recursos

Further reading

Pronto quando você estiver

Pare de pagar por desenvolvedor.
Comece a fechar o ciclo.

O Plexicus é o ASPM nativo de IA que verifica, filtra, corrige, pentesta e explica — de forma autónoma. Programadores ilimitados, repos ilimitados, ações de IA de utilização justa. Nível gratuito real, €269/mo anual quando estiver pronto.

Começar grátis Reservar uma demo