hacktricks/binary-exploitation/integer-overflow.md

# इंटीजर ओवरफ्लो

{% hint style="success" %}
AWS हैकिंग सीखें और अभ्यास करें:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks प्रशिक्षण AWS रेड टीम एक्सपर्ट (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
GCP हैकिंग सीखें और अभ्यास करें: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks प्रशिक्षण GCP रेड टीम एक्सपर्ट (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>हैकट्रिक्स का समर्थन करें</summary>

* [**सदस्यता योजनाएं**](https://github.com/sponsors/carlospolop) की जाँच करें!
* **शामिल हों** 💬 [**डिस्कॉर्ड समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या हमें **ट्विटर** 🐦 पर **फॉलो** करें [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **हैकिंग ट्रिक्स साझा करें, PRs सबमिट करके** [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github रेपो में।

</details>
{% endhint %}

## मूल जानकारी

**इंटीजर ओवरफ्लो** के मूल में कंप्यूटर प्रोग्रामिंग में डेटा प्रकारों की **साइज** द्वारा लगाई गई सीमा और डेटा की **व्याख्या** है।

उदाहरण के लिए, एक **8-बिट असाइन्ड इंटीजर** मान्यता दे सकता है **0 से 255** तक के मान। यदि आप 8-बिट असाइन्ड इंटीजर में मान 256 स्टोर करने का प्रयास करते हैं, तो इसकी स्टोरेज क्षमता की सीमा के कारण यह 0 पर वापस लौट जाएगा। उसी तरह, एक **16-बिट असाइन्ड इंटीजर** के लिए, जो मान सकता है **0 से 65,535** तक के मान, 65,535 में 1 जोड़ने से मान फिर से 0 पर वापस जाएगा।

इसके अतिरिक्त, एक **8-बिट साइन्ड इंटीजर** मान सकता है **-128 से 127** तक के मान। इसका कारण यह है कि एक बिट का उपयोग साइन (सकारात्मक या नकारात्मक) को प्रतिनिधित करने के लिए किया जाता है, जिससे 7 बिट उत्कृष्टता को प्रतिनिधित करने के लिए बचते हैं। सबसे नकारात्मक संख्या को **-128** (बाइनरी `10000000`) के रूप में प्रतिनिधित किया जाता है, और सबसे सकारात्मक संख्या है **127** (बाइनरी `01111111`)।

### अधिकतम मान

संभावित **वेब सुरक्षा दोष** के लिए अधिकतम समर्थित मानों को जानना बहुत दिलचस्प है:

{% tabs %}
{% tab title="Rust" %}
```rust
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);
}
```
{% endtab %}

{% tab title="C" %}इंटीजर ओवरफ्लो क्या है? %}
```c
#include <stdio.h>
#include <limits.h>

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;
}
```
## उदाहरण

### प्योर ओवरफ्लो

छापा गया परिणाम 0 होगा क्योंकि हमने char को ओवरफ्लो कर दिया है:
```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;
}
```
### साइन्ड से अनसाइन्ड कन्वर्शन

एक स्थिति का विचार करें जहाँ एक साइन्ड इंटीजर उपयोगकर्ता इनपुट से पढ़ा जाता है और फिर उसे एक संदर्भ में उपयोग किया जाता है जो इसे एक असाइन्ड इंटीजर के रूप में देखता है, सही मान्यता के बिना:
```c
#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;
}
```
### अन्य उदाहरण

* [https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html)
* केवल 1B का उपयोग पासवर्ड के आकार को संग्रहित करने के लिए किया जाता है, इसे ओवरफ्लो करना संभव है और इसे यह महसूस करने के लिए बनाया जा सकता है कि यह 4 की लंबाई है जबकि वास्तव में यह 260 है ताकि लंबाई की जांच सुरक्षा को छल सके
* [https://guyinatuxedo.github.io/35-integer\_exploitation/puzzle/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/puzzle/index.html)
* कुछ नंबर दिए गए हैं, z3 का उपयोग करके पहले नंबर को गुणित करने पर दूसरे नंबर को देने वाला एक नया नंबर खोजें:&#x20;

```
(((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569)
```
* [https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/)
* केवल 1B का उपयोग पासवर्ड के आकार को संग्रहित करने के लिए किया जाता है, इसे ओवरफ्लो करना संभव है और इसे यह महसूस करने के लिए बनाया जा सकता है कि यह 4 की लंबाई है जबकि वास्तव में यह 260 है ताकि लंबाई की जांच सुरक्षा को छल सके और स्टैक में अगले स्थानीय चर को ओवरराइट कर सुरक्षा को छल सके

## ARM64

यह **ARM64 में बदलाव नहीं होता** जैसा कि आप [**इस ब्लॉग पोस्ट**](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/) में देख सकते हैं।