Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-03 18:10:07 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/integer-overflow.md

8.3 KiB
Raw Blame History

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

{% hint style="success" %} AWS हैकिंग सीखें और अभ्यास करें:HackTricks प्रशिक्षण AWS रेड टीम एक्सपर्ट (ARTE)
GCP हैकिंग सीखें और अभ्यास करें: HackTricks प्रशिक्षण GCP रेड टीम एक्सपर्ट (GRTE)

हैकट्रिक्स का समर्थन करें
{% 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" %}

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" %}इंटीजर ओवरफ्लो क्या है? %}

#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 को ओवरफ्लो कर दिया है:

#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;
}

साइन्ड से अनसाइन्ड कन्वर्शन

एक स्थिति का विचार करें जहाँ एक साइन्ड इंटीजर उपयोगकर्ता इनपुट से पढ़ा जाता है और फिर उसे एक संदर्भ में उपयोग किया जाता है जो इसे एक असाइन्ड इंटीजर के रूप में देखता है, सही मान्यता के बिना:

#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
  • केवल 1B का उपयोग पासवर्ड के आकार को संग्रहित करने के लिए किया जाता है, इसे ओवरफ्लो करना संभव है और इसे यह महसूस करने के लिए बनाया जा सकता है कि यह 4 की लंबाई है जबकि वास्तव में यह 260 है ताकि लंबाई की जांच सुरक्षा को छल सके
  • https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html
  • कुछ नंबर दिए गए हैं, z3 का उपयोग करके पहले नंबर को गुणित करने पर दूसरे नंबर को देने वाला एक नया नंबर खोजें: 
(((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569)
  • https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/
  • केवल 1B का उपयोग पासवर्ड के आकार को संग्रहित करने के लिए किया जाता है, इसे ओवरफ्लो करना संभव है और इसे यह महसूस करने के लिए बनाया जा सकता है कि यह 4 की लंबाई है जबकि वास्तव में यह 260 है ताकि लंबाई की जांच सुरक्षा को छल सके और स्टैक में अगले स्थानीय चर को ओवरराइट कर सुरक्षा को छल सके

ARM64

यह ARM64 में बदलाव नहीं होता जैसा कि आप इस ब्लॉग पोस्ट में देख सकते हैं।