### चुनौती बाइनरी

लक्ष्य एक सामान्य C प्रोग्राम है जो मेमोरी में एक फ़्लैग संग्रहीत करता है और उसका वर्चुअल पता प्रिंट करता है:```c
#include <stdio.h>
#include <unistd.h>

int main(void)
{
    char secret[] = "FLAG{p4g3_t4bl3_w4lk3r}";

    printf("secret @ %p\n", (void *)secret);
    printf("pid = %d\n", getpid());
    printf("Spinning. Walk the page tables to find the flag.\n");

    while (1)
    {
    }
}

स्क्रिप्ट बंडल कर्नेल और initramfs को QEMU के तहत `-s` (gdb सर्वर `localhost:1234` पर) और `nokaslr` के साथ बूट करती है ताकि कर्नेल पते रनों के बीच स्थिर रहें।

VM तुरंत बूट होता है और चुनौती बाइनरी चलती है। आप कंसोल पर फ़्लैग का वर्चुअल पता प्रिंट होता देखेंगे।```
secret @ 0x7ffe08985c90
pid = 1
Spinning. Walk the page tables to find the flag.

![gdb टर्मिनल अटैच करने के बाद, रुका हुआ और तैयार](https://assets.kitploit.com/production/public/readmes/12435/9fb13e082596378677ea0d42cf7da3a86706df44127860fc724b2bad0a9f138c.png)

---

## वर्चुअल एड्रेस को विघटित करना

आपके पास एक वर्चुअल एड्रेस है। लेकिन डेटा, _वास्तव में_ कहाँ है?

वर्चुअल एड्रेस ऑपरेटिंग सिस्टम का एक शिष्ट कल्पना (polite fiction) हैं। हर प्रक्रिया सोचती है कि उसकी अपनी निजी मेमोरी शून्य से शुरू होती है। वास्तव में, डेटा फिजिकल RAM में किसी पूरी तरह से असंबंधित स्थान पर रहता है। पेज टेबल दोनों के बीच का नक्शा है: एक पेड़ संरचना जिसे CPU हर एक मेमोरी एक्सेस पर चलता है (या अपने TLB कैश से देखता है)।

तो चलिए वही करते हैं जो CPU करता है। मैन्युअली। उस एड्रेस का अनुवाद करने के लिए, हमें इसे उन सूचकांकों में विघटित करना होगा जिनका उपयोग CPU प्रत्येक स्तर पर करता है।

एक x86-64 वर्चुअल एड्रेस 48 बिट चौड़ा होता है। उन 48 बिटों को पाँच क्षेत्रों में विभाजित किया गया है:```
 63    48 47    39 38    30 29    21 20    12 11       0
┌────────┬────────┬────────┬────────┬────────┬──────────┐
│ sign   │  PGD   │  PUD   │  PMD   │   PT   │  Offset  │
│ extend │ index  │ index  │ index  │ index  │          │
│ (16b)  │ (9b)   │ (9b)   │ (9b)   │ (9b)   │  (12b)   │
└────────┴────────┴────────┴────────┴────────┴──────────┘

gdb में, आप इन्हें सीधे गणना कर सकते हैं:```
(gdb) p/x (0x7ffe08985c90 >> 39) & 0x1ff
$1 = 0xff
(gdb) p/x (0x7ffe08985c90 >> 30) & 0x1ff
$2 = 0x1f8
(gdb) p/x (0x7ffe08985c90 >> 21) & 0x1ff
$3 = 0x44
(gdb) p/x (0x7ffe08985c90 >> 12) & 0x1ff
$4 = 0x185
(gdb) p/x 0x7ffe08985c90 & 0xfff
$5 = 0xc90

पेज टेबल बेस `0x66c7000` है। निचले 12 बिट PCID/फ़्लैग्स (यहाँ शून्य) हैं, इसलिए बेस पता ज्यों का त्यों मान है।

यहीं से वॉक शुरू होता है।

---

## वॉक

यहाँ ट्रिक है: हर स्तर एक ही पैटर्न का पालन करता है। फ़्लैग्स स्तरों के बीच थोड़े भिन्न होते हैं, लेकिन प्रक्रिया नहीं बदलती। पैटर्न:

1. **प्रविष्टि पता निकालें:** `base + index * 8` (प्रत्येक प्रविष्टि 8 बाइट्स है)
2. **भौतिक मेमोरी से प्रविष्टि पढ़ें** QEMU मॉनिटर के `xp` कमांड का उपयोग करके
3. **फ़्लैग्स को डिकोड करें** (नीचे दिए गए संदर्भ देखें)। यदि Present (बिट 0) 0 है, तो पेज मैप नहीं हुआ है और वॉक रुक जाता है
4. **अगले टेबल का बेस निकालें:** प्रविष्टि को `& 0x000FFFFFFFFFF000` से मास्क करें
5. **अगले स्तर पर जाएँ**

प्रत्येक प्रविष्टि 64 बिट्स की होती है। सामान्य फ़्लैग बिट्स:```
Bit   Name              Meaning when set
 0    Present           Page/table is mapped
 1    Read/Write        Writable
 2    User/Supervisor   Accessible from userspace
 3    Write-Through     Write-through caching
 4    Cache Disable     Caching disabled
 5    Accessed          CPU has read this entry
 6    Dirty             CPU has written to the page (final level only)
 7    Page Size         1 GB page (PUD) or 2 MB page (PMD)
63    NX                No-execute

इसे gdb से QEMU के भौतिक मेमोरी जाँच कमांड का उपयोग करके पढ़ें:```
(gdb) monitor xp/1gx 0x66c77f8
000000066c77f8: 0x0000000006713067

.(No input provided)```
(gdb) monitor xp/1gx 0x6713fc0
00000006713fc0: 0x00000000066ac067

| [ZMap](https://zmap.io/) | इंटरनेट-व्यापी नेटवर्क स्कैनर। |
|--------|--------|
| [Zgrab2](https://github.com/zmap/zgrab2) | ZMap के साथ संचालित होने वाला Go-आधारित एप्लिकेशन लेयर स्कैनर। |

## 📊 नेटवर्क विश्लेषण

नेटवर्क ट्रैफ़िक विश्लेषण, ट्रैफ़िक निरीक्षण, नेटवर्क फोरेंसिक्स, नेटवर्क निगरानी और पैकेट कैप्चर निरीक्षण के लिए समर्पित उपकरण, जो विसंगतियों की पहचान करने, कलाकृतियों को निकालने और घटना प्रतिक्रिया में सहायता करने में मदद करते हैं।```
(gdb) monitor xp/1gx 0x66ac220
000000066ac220: 0x00000000066c4067

कृपया अनुवाद करने के लिए मार्कडाउन सामग्री प्रदान करें।```
(gdb) monitor xp/1gx 0x66c4c28
000000066c4c28: 0x80000000037fd867

(empty)```
(gdb) monitor xp/1gx 0x66c7000 + 0x82 * 8
00000000066c7410: 0x0000000000000000

अब इसे पढ़ें:```
(gdb) monitor xp/6bx 0x37fdc90
00000000037fdc90: 0x46 0x4c 0x41 0x47 0x7b 0x70

"

But there's an empty line then "response"? Actually, it's the end of the user message. The assistant is supposed to respond. The user says: "Translate the following Kitploit tool content. ... INPUT:" and then immediately ""? No, re-reading:

User message: "Translate the following Kitploit tool content.
This is chunk 47 of 69 from a longer Markdown document being translated in sequence.
...
7. If the chunk starts mid-paragraph, continue translating from that point. Do not add a leading newline or indent unless it exists in the source.

INPUT:

"

The user typed "INPUT:" and then presumably provided the source text? But after "INPUT:" there is an empty line, then the assistant "thought" block begins? Actually, the structure is: user message ends with "INPUT:" and then nothing? The assistant then started with "Thinking..." But the assistant's response should be the translation. So the user provided the source text after INPUT:? In the prompt, maybe it's missing? Let's look carefully: The user message says:

Then the assistant's "thinking" block appears. So the "INPUT:" line is part of the user's message, and the actual source text that needs to be translated might be missing from the prompt. But the assistant's instructions say: "You are a specialised cybersecurity tool content translator ... Your sole function is to produce accurate, idiomatic, and concise translations of Markdown content from one language to another." And then: "Translate the following Kitploit tool content. This is chunk 47 of 69 ... INPUT:". Then there's nothing? That would be an empty input. The assistant must have received an empty chunk. Possibly the chunk content got lost in the prompt construction. Since it's a test or a dummy run, maybe the input is empty. In that case, the assistant should output nothing? But the rules say: "Return ONLY the translated text. No preamble, no commentary..." If the source is empty, the translation is empty. So I should output nothing. However, the assistant's "thinking" indicates that it's analyzing the situation and might realize there's no input. Since it's told to translate only the exact text provided, and the provided text is empty, the output should be an empty string. So I'll respond with an empty response.```
FLAG{p4g3_t4bl3_w4lk3r}

## ध्वज और अनुमतियाँ

हमने वॉक के दौरान प्रत्येक स्तर पर फ्लैग को डिकोड किया लेकिन सुरक्षा के लिए उनका क्या अर्थ है, यह छोड़ दिया। अंतिम PTE देखें:```
0x80000000037fd867

यह समझ में आता है: सीक्रेट एक स्टैक वेरिएबल है। स्टैक पढ़ने योग्य, लिखने योग्य और गंदा (इसमें लिखा गया है) होता है। इसे नो-एक्जीक्यूट चिह्नित किया गया है क्योंकि आधुनिक सिस्टम W^X लागू करते हैं: एक पेज जो लिखने योग्य है, उसे एक्जीक्यूटेबल नहीं होना चाहिए।

हर स्तर पर फ्लैग्स हार्डवेयर द्वारा ANDed होते हैं। यदि PUD एंट्री में User=0 है, तो PTE जो कुछ भी कहे, उसके नीचे कुछ भी उपयोगकर्ता-सुलभ नहीं है। सबसे प्रतिबंधात्मक अनुमति लागू होती है।

---

## TLB: जब CPU वॉक को छोड़ देता है

एक बाइट तक पहुँचने के लिए चार मेमोरी रीड। यह महँगा है। CPU वास्तव में हर मेमोरी एक्सेस पर पेज टेबल को वॉक नहीं करता। यह परिणाम को **ट्रांसलेशन लुकसाइड बफर (TLB)** में कैश करता है।

हमारे फ्लैग के वर्चुअल एड्रेस पर पहली एक्सेस के बाद, CPU मैपिंग `0x7ffe08985c90 -> 0x37fdc90` (लगभग) को TLB में स्टोर करता है। बाद की एक्सेस कैश में हिट होती हैं और वॉक को पूरी तरह से छोड़ देती हैं। पेज टेबल RAM में बिना छुए बैठी रहती है।

यह सामान्य कोड के लिए पारदर्शी है। लेकिन यह उसी क्षण मायने रखता है जब आप पेज टेबल एंट्री को _संशोधित_ करते हैं। यदि आप PTE में एक नया भौतिक पता लिखते हैं, तो CPU को पता नहीं चलता: TLB में अभी भी पुराना मैपिंग है। आपको इसे स्पष्ट रूप से फ्लश करना होगा।

कर्नेल `invlpg` इंस्ट्रक्शन के साथ ऐसा करता है, जो एकल वर्चुअल एड्रेस के लिए TLB एंट्री को अमान्य करता है। यूज़रस्पेस से `mprotect` कॉल करें और हुड के नीचे यही होता है: कर्नेल PTE फ्लैग्स को अपडेट करता है, फिर TLB को फ्लश करता है ताकि CPU नई अनुमतियों को उठा ले।

इसके सीधे सुरक्षा निहितार्थ हैं। कर्नेल एक्सप्लॉइट में, यदि आप PTE में लिखने में सफल होते हैं (जैसे, NX बिट को साफ़ करके स्टैक को एक्जीक्यूटेबल बनाना), तो आपको TLB को भी फ्लश करने की आवश्यकता होती है, इससे पहले कि CPU परिवर्तन का सम्मान करे। कभी-कभी कर्नेल आपके लिए इसे उस कोड पथ के साइड इफेक्ट के रूप में करता है जिसे आपने ट्रिगर किया। कभी-कभी आपको इसे स्वयं व्यवस्थित करने की आवश्यकता होती है। किसी भी तरह, आपको यह जानना होगा कि TLB मौजूद है, अन्यथा आपका एक्सप्लॉइट सिद्धांत रूप में काम करता है लेकिन व्यवहार में नहीं।

---

## ह्यूज पेज: जब वॉक जल्दी समाप्त होता है

ऊपर दिए गए वॉकथ्रू में, हम चारों स्तरों से गुज़रे। लेकिन वॉक जल्दी समाप्त हो सकता है यदि पेज साइज़ बिट (बिट 7) सेट है।

**स्तर 3 (PUD) पर:** यदि बिट 7 सेट है, तो एंट्री सीधे 1 GB पेज को मैप करती है। भौतिक पता एंट्री से लिया जाता है, और वर्चुअल एड्रेस के बिट्स [29:0] ऑफसेट बन जाते हैं (30 बिट = 1 GB)।

**स्तर 2 (PMD) पर:** यदि बिट 7 सेट है, तो एंट्री 2 MB पेज को मैप करती है। वर्चुअल एड्रेस के बिट्स [20:0] ऑफसेट बन जाते हैं (21 बिट = 2 MB)।

आप अक्सर कर्नेल मैपिंग में ह्यूज पेज देखेंगे। कर्नेल का डायरेक्ट-मैप क्षेत्र (`0xffff888000000000` अधिकांश 64-बिट कर्नेल पर) अक्सर TLB दबाव को कम करने के लिए 2 MB या 1 GB पेज का उपयोग करता है।

यदि आप अपने वॉक के दौरान एक ह्यूज पेज का सामना करते हैं, तो सूत्र बदल जाता है:```
2 MB page:  phys = (PMD_entry & 0x000FFFFFFFE00000) | (VA & 0x1FFFFF)
1 GB page:  phys = (PUD_entry & 0x000FFFFFC0000000) | (VA & 0x3FFFFFFF)

# Decompose the virtual address
pgd_idx = (va >> 39) & 0x1FF
pud_idx = (va >> 30) & 0x1FF
pmd_idx = (va >> 21) & 0x1FF
pt_idx  = (va >> 12) & 0x1FF
offset  =  va        & 0xFFF

# Walk: each level is the same pattern
pgd_entry = read_phys(pgd_base + pgd_idx * 8)
if not (pgd_entry & 1): return None       # Not present
pud_base = pgd_entry & ADDR_MASK

pud_entry = read_phys(pud_base + pud_idx * 8)
if not (pud_entry & 1): return None
if pud_entry & (1 << 7):                   # 1 GB huge page
    return (pud_entry & 0x000FFFFFC0000000) | (va & 0x3FFFFFFF)
pmd_base = pud_entry & ADDR_MASK

pmd_entry = read_phys(pmd_base + pmd_idx * 8)
if not (pmd_entry & 1): return None
if pmd_entry & (1 << 7):                   # 2 MB huge page
    return (pmd_entry & 0x000FFFFFFFE00000) | (va & 0x1FFFFF)
pt_base = pmd_entry & ADDR_MASK

pt_entry = read_phys(pt_base + pt_idx * 8)
if not (pt_entry & 1): return None

return (pt_entry & ADDR_MASK) | offset

पूरी स्क्रिप्ट (फ्लैग डिकोडिंग और सुंदर आउटपुट के साथ) `pagewalk.py` में है। इसे सोर्स करें और अपने मैन्युअल कार्य को सत्यापित करने के लिए या अन्य पतों का पता लगाने के लिए उपयोग करें:```
(gdb) source ./pagewalk.py
Page walk command loaded. Usage: pagewalk <virtual-address>
(gdb) pagewalk 0x7ffe08985c90
Decoded Virtual Address:
  PGD=0x0ff
  PUD=0x1f8
  PMD=0x044
  PT=0x185
  Offset=0xc90

CR3: 0x00000000066c7000
PGD[0x0ff]:  0x0000000006713067  [Present RW User Accessed Dirty]
PUD[0x1f8]:  0x00000000066ac067  [Present RW User Accessed Dirty]
PMD[0x044]:  0x00000000066c4067  [Present RW User Accessed Dirty]
PT[0x185]:   0x80000000037fd867  [Present RW User Accessed Dirty NX]

Physical address: 0x00000000037fdc90

समान भौतिक मेमोरी, जो एक कर्नेल वर्चुअल पते के माध्यम से एक्सेस की जाती है। इस प्रकार कर्नेल स्वयं
मनमानी भौतिक मेमोरी पढ़ता है: `phys_to_virt()` बस
`page_offset_base + phys_addr` है।

यही कारण है कि कर्नेल एक्सप्लॉइट `page_offset_base` को लीक करने के बारे में ध्यान रखते हैं। यदि KASLR
सक्षम है, तो आप नहीं जानते कि डायरेक्ट मैप कहाँ से शुरू होता है, इसलिए आप भौतिक पतों को कर्नेल वर्चुअल पतों में परिवर्तित नहीं कर सकते। आधार को लीक करें, और आप
डायरेक्ट मैप के माध्यम से किसी भी भौतिक पते को पढ़ या लिख सकते हैं, जिसमें पेज तालिका
प्रविष्टियाँ स्वयं शामिल हैं।

---

## किसी दूसरी प्रक्रिया के पेज टेबल ढूँढना

हमारे सेटअप ने गारंटी दी कि जब gdb ने VM को रोका तो CR3 चैलेंज बाइनरी की पेज तालिकाओं की ओर इशारा कर रहा था। लेकिन क्या होगा यदि आपको एक _अलग_ प्रक्रिया के पेज टेबल को चलने की आवश्यकता है?

प्रत्येक प्रक्रिया का CR3 मान उसके `task_struct` में संग्रहीत होता है। पथ है:```
task_struct -> mm_struct -> pgd -> physical page

यह डायरेक्ट मैप में एक कर्नेल वर्चुअल एड्रेस है। फिजिकल एड्रेस प्राप्त करने के लिए बेस को हटाएं:```
0xffff8880066c7000 - 0xffff888000000000 = 0x66c7000