Integer Overflow

Leer en oefen AWS-hacking: HackTricks Opleiding AWS Red Team Expert (ARTE) Leer en oefen GCP-hacking: HackTricks Opleiding GCP Red Team Expert (GRTE)

Ondersteun HackTricks

• Controleer die inskrywingsplanne!

• Sluit aan by die 💬 Discord-groep of die telegram-groep of volg ons op Twitter 🐦 @hacktricks_live.

• Deel hacking-truuks deur PR's in te dien by die HackTricks en HackTricks Cloud github-opslag.

Basiese Inligting

In die kern van 'n integer oorvloei is die beperking wat opgelê word deur die grootte van data tipes in rekenaarsprogrammering en die interpretasie van die data.

Byvoorbeeld, 'n 8-bit ondertekenlose heelgetal kan waardes van 0 tot 255 voorstel. As jy probeer om die waarde 256 in 'n 8-bit ondertekenlose heelgetal te stoor, sal dit na 0 oorvloei as gevolg van die beperking van sy stoorvermoë. Op soortgelyke wyse, vir 'n 16-bit ondertekenlose heelgetal, wat waardes van 0 tot 65,535 kan hou, sal die byvoeging van 1 tot 65,535 die waarde terug na 0 bring.

Verder kan 'n 8-bit ondertekende heelgetal waardes van -128 tot 127 voorstel. Dit is omdat een bit gebruik word om die teken (positief of negatief) voor te stel, wat 7 bits oorlaat om die grootte voor te stel. Die mees negatiewe getal word voorgestel as -128 (binêre 10000000), en die mees positiewe getal is 127 (binêre 01111111).

Maksimum waardes

Vir potensiële web kwesbaarhede is dit baie interessant om die maksimum ondersteunde waardes te ken:

fn main() {

let mut quantity = 2147483647;

let (mul_result, _) = i32::overflowing_mul(32767, quantity);
let (add_result, _) = i32::overflowing_add(1, quantity);

println!("{}", mul_result);
println!("{}", add_result);
}

Integer overflow occurs when an arithmetic operation results in a value that exceeds the maximum size that the data type can hold. This can lead to unexpected behavior in the program, such as wrapping around to a minimum value or causing a buffer overflow. Integer overflow can be exploited by an attacker to manipulate the program's behavior and potentially execute malicious code.

```c #include #include

int main() { int a = INT_MAX; int b = 0; int c = 0;

b = a * 100; c = a + 1;

printf("%d\n", INT_MAX); printf("%d\n", b); printf("%d\n", c); return 0; }

## Voorbeelde

### Skoon oorvloei

Die gedrukte resultaat sal 0 wees aangesien ons die karakter oorvloei het:
```c
#include <stdio.h>

int main() {
unsigned char max = 255; // 8-bit unsigned integer
unsigned char result = max + 1;
printf("Result: %d\n", result); // Expected to overflow
return 0;
}

Onderteken na Ondertekenloos Omskakeling

Oorweeg 'n situasie waar 'n ondertekende heelgetal van gebruikersinvoer gelees word en dan in 'n konteks gebruik word wat dit as 'n ondertekenloos heelgetal hanteer, sonder behoorlike validering:

#include <stdio.h>

int main() {
int userInput; // Signed integer
printf("Enter a number: ");
scanf("%d", &userInput);

// Treating the signed input as unsigned without validation
unsigned int processedInput = (unsigned int)userInput;

// A condition that might not work as intended if userInput is negative
if (processedInput > 1000) {
printf("Processed Input is large: %u\n", processedInput);
} else {
printf("Processed Input is within range: %u\n", processedInput);
}

return 0;
}

In hierdie voorbeeld, as 'n gebruiker 'n negatiewe nommer invoer, sal dit geïnterpreteer word as 'n groot ondertekenlose heelgetal as gevolg van die manier waarop binêre waardes geïnterpreteer word, wat moontlik tot onverwagte gedrag kan lei.

Ander Voorbeelde

• https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html

• Slegs 1B word gebruik om die grootte van die wagwoord te stoor, sodat dit moontlik is om dit te oorvloei en dit te laat dink dat dit 'n lengte van 4 is terwyl dit eintlik 260 is om die lengtekontrolebeskerming te omseil

• https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html

• Gegee 'n paar getalle, vind met behulp van z3 'n nuwe getal wat met die eerste vermenigvuldig sal word om die tweede een te gee:

(((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569)

• https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/

• Slegs 1B word gebruik om die grootte van die wagwoord te stoor, sodat dit moontlik is om dit te oorvloei en dit te laat dink dat dit 'n lengte van 4 is terwyl dit eintlik 260 is om die lengtekontrolebeskerming te omseil en in die stapel die volgende plaaslike veranderlike te oorskryf en beide beskermings te omseil

ARM64

Dit verander nie in ARM64 soos gesien kan word in hierdie blogpos.