# Java4Shell (CVE-2026-114938): ഒരു 65-അക്ഷര സ്ട്രിംഗും OpenJDK-യുടെ Base64 ഡീകോഡറും

Published: 2026-11-19

65 പ്രതീകങ്ങളുള്ള ഒരു Base64 സ്ട്രിംഗ് (64 അക്ഷരം A-കളും ഒരു സമചിഹ്നവും) OpenJDK-യുടെ AVX-512 Base64 ഡീകോഡറിനെ x86-64-ൽ 50-ബൈറ്റ് അറേയുടെ അവസാനം 62 ബൈറ്റുകൾ എഴുതാൻ പ്രേരിപ്പിക്കുന്നുവെന്ന് കലിഫ് റിപ്പോർട്ട് ചെയ്യുന്നു, അതിനുമുമ്പ് Java ഒരു അപവാദം സഹിതം ഇൻപുട്ട് നിരസിക്കുന്നു. OpenJDK-യും Oracle-യും നവംബർ 17-ന് ഫിക്സുകൾ പ്രസിദ്ധീകരിച്ചു (CVSS 3.1 8.1; കലിഫ് ഇതിന് CVSS 4.0-ൽ 9.2 സ്കോർ നൽകി). കലിഫ് പറയുന്നത്, അവർ ഓവർറൈറ്റിനെ പതിനൊന്ന് ഉൽപ്പന്നങ്ങളിൽ കോഡ് എക്സിക്യൂഷനാക്കി മാറ്റി, പാചകക്കുറിപ്പുകൾ അവർ രഹസ്യമായി സൂക്ഷിക്കുന്നു എന്നാണ്. CISA പാച്ചിംഗ് അഭ്യർത്ഥിച്ചു; നവംബർ 18-ന് പരിശോധിച്ചപ്പോൾ CVE അതിന്റെ Known Exploited Vulnerabilities ലിസ്റ്റിൽ ഉണ്ടായിരുന്നില്ല.

Canonical: https://thedailydiff.dev/ml/video/2026-11-18-java4shell-base64/

## ഈ വീഡിയോയിൽ ഉൾപ്പെടുന്ന കാര്യങ്ങൾ

- ബഗ് HotSpot-ന്റെ C2 കംപൈലർ Base64 ഡീകോഡിംഗിനായി മാറ്റിവയ്ക്കുന്ന ഒരു കൈകൊണ്ട് എഴുതിയ x86-64 അസംബ്ലി റൂട്ടീനിലാണ്. 65 പ്രതീകങ്ങളുള്ള ഇൻപുട്ടിനായി Java 50-ബൈറ്റ് അറേ അനുവദിക്കുകയും റൂട്ടീൻ 48-ൽ നിന്ന് ആരംഭിച്ച് പൂർണ്ണമായ 64-ബൈറ്റ് ബ്ലോക്ക് എഴുതുകയും ചെയ്യുന്നു, അതിനാൽ 62 ബൈറ്റുകൾ അവസാനത്തിനുശേഷം എത്തുന്നു. കലിഫിന്റെ വിവരണം, ഇവിടെ അവരുടേതായി പുനർനിർമ്മിച്ചിരിക്കുന്നു; ഞങ്ങൾ ഒന്നും പ്രവർത്തിപ്പിച്ചിട്ടില്ല.
- പാഡ് ചെയ്ത ടെയിലിനായി ലെങ്ത് അരിത്മെറ്റിക് മൈനസ് ഒന്നിലേക്ക് അണ്ടർഫ്ലോ ചെയ്യുന്നു, മാസ്ക് ഇൻസ്ട്രക്ഷൻ അതിനെ എല്ലാം ഒന്നുകളായി കണക്കാക്കുന്നു, കൂടാതെ എഴുത്ത് സംഭവിച്ചതിന് ശേഷം മാത്രമേ Java IllegalArgumentException നൽകുന്നുള്ളൂ.
- സ്കോപ്പ്: OpenJDK 17.0.6-ഉം അതിനുശേഷമുള്ളവയും (OpenJDK-യുടെ മാട്രിക്സ് 17, 21, 25, 27 എന്നിവ അടയാളപ്പെടുത്തുന്നു), AVX-512 VBMI ഉള്ള x86-64 CPU-കളിൽ (ഇന്റൽ ഐസ് ലേക്ക് മുതലുള്ളവ, AMD Zen 4 മുതലുള്ളവ). ARM64 ബാധിച്ചിട്ടില്ല. സ്റ്റാൻഡേർഡ് Java 8, 11 എന്നിവ ഈ CVE-യിൽ ഇല്ല; Oracle അതിന്റെ Java 8 പെർഫോമൻസ് ബിൽഡും ലിസ്റ്റ് ചെയ്യുന്നു.
- കലിഫ് പറയുന്നത്, ഡിഫോൾട്ട് സജ്ജീകരണങ്ങളിൽ പതിനൊന്ന് ഉൽപ്പന്നങ്ങളിൽ കോഡ് എക്സിക്യൂഷൻ അവർക്ക് ലഭിച്ചു (Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate ലോഗിൻ ഇല്ലാതെ; Kafka, Solr, Elasticsearch, Gerrit, Spinnaker എന്നിവ ഒന്നിന് ശേഷം). ഇത് കലിഫിന്റെ സ്വന്തം പരിശോധനകളാണ്; ഉൽപ്പന്ന പാചകക്കുറിപ്പുകൾ രഹസ്യമായി സൂക്ഷിക്കുന്നു, സാർവത്രിക എക്സ്പ്ലോയിറ്റ് ഇല്ലെന്ന് കലിഫ് പറയുന്നു.
- വെണ്ടർമാർ സ്ഥിരീകരിച്ചു: OpenJDK-യും Oracle-യും CVE-2026-114938 (CVSS 3.1 8.1) ലിസ്റ്റ് ചെയ്യുന്നു; Oracle JDK 17.0.21.1 നവംബർ 17-ന് പുറത്തിറക്കി; Corretto-യ്ക്ക് ഫിക്സ് ചെയ്ത ബിൽഡുകൾ ഉണ്ട്; Temurin പരിശോധന പൂർത്തിയാകുമ്പോൾ പുറത്തിറക്കുന്നു; Red Hat ഫിക്സുകൾ വേഗത്തിലാക്കുന്നു. പൊതുവായ OpenJDK നവംബർ സുരക്ഷാ ബ്രാഞ്ചിൽ Base64 ഒപ്റ്റിമൈസേഷൻ മെച്ചപ്പെടുത്തലുകൾ എന്ന തലക്കെട്ടിൽ നാല് വരി മാറ്റം അടങ്ങിയിരിക്കുന്നു.
- പ്രതിവിധി: ഒരു ഫിക്സ് ചെയ്ത ബിൽഡിലേക്ക് അപ്ഡേറ്റ് ചെയ്യുക, അല്ലെങ്കിൽ ഏതെങ്കിലും ചിപ്പിൽ -XX:-UseBASE64Intrinsics ഉപയോഗിച്ച് JVM ആരംഭിക്കുക (-XX:UseAVX=2 x86-64-ൽ മാത്രമേ പ്രവർത്തിക്കൂ, ARM JVM-കൾ ആരംഭിക്കുന്നത് തടയുന്നു). Linux-ൽ, കലിഫിന്റെ പരിശോധന നാല് CPU ഫ്ലാഗുകൾ പ്രിന്റ് ചെയ്യുന്നു; ഒരു മെഷീൻ പരിധിയിൽ വരാൻ ഈ നാല് ഫ്ലാഗുകളും (avx512f, avx512bw, avx512vbmi, bmi2) ഉണ്ടായിരിക്കണം. കണ്ടെയ്നർ ചിത്രങ്ങൾ വീണ്ടും നിർമ്മിക്കുക.
- നവംബർ 17-ന് CISA ഉടനടി പാച്ചിംഗ് അഭ്യർത്ഥിച്ചു; നവംബർ 18-ന് പരിശോധിച്ചപ്പോൾ CVE അതിന്റെ Known Exploited Vulnerabilities കാറ്റലോഗിൽ (പതിപ്പ് 2026.11.17) ഉണ്ടായിരുന്നില്ല. സുരക്ഷാ സ്ഥാപനമായ Hadrian പറയുന്നത്, ഇത് ഒരു ലാബിൽ ലോഗിൻ പരിശോധനകൾ തകർക്കുകയും കോഡ് എക്സിക്യൂഷൻ നേടുകയും ചെയ്തു എന്നാണ്; അത് അവരുടെ സ്വന്തം അവകാശവാദമാണ്. വിധി: SHIP IT.
- വിഷ്വൽ ക്രെഡിറ്റുകൾ: calif.io/java4shell-ന്റെ ഭാഗങ്ങളും ഒരു ചെറിയ റെക്കോർഡിംഗും Calif.io-യ്ക്ക് ക്രെഡിറ്റ് ചെയ്യുന്നു; Java-യുടെ സ്രഷ്ടാവായ James Gosling-ന്റെ ലഘുചിത്ര ഛായാചിത്രം Peter Campbell, CC BY-SA 4.0 Wikimedia Commons വഴി, The Daily Diff ക്രോപ്പ് ചെയ്യുകയും അനുരൂപമാക്കുകയും ചെയ്തു, അദ്ദേഹം ഈ ഗവേഷണത്തിന് അംഗീകാരം നൽകുകയോ അതിനോട് പ്രതികരിക്കുകയോ ചെയ്തിട്ടില്ല; The Naked Gun (1988) എന്ന സിനിമയിൽ നിന്നുള്ള രണ്ട് സെക്കൻഡ് നിശബ്ദ ഉദ്ധരണി GIPHY വഴി, സിനിമയുടെ ഉടമകൾ അവരുടെ അവകാശങ്ങൾ നിലനിർത്തുന്നു.

## ചോദ്യോത്തരങ്ങൾ

### എന്താണ് Java4Shell, എന്തുകൊണ്ടാണ് Java-യുടെ പിശക് വളരെ വൈകി എത്തുന്നത്?

Java4Shell എന്നത് CVE-2026-114938 ആണ്, OpenJDK-യുടെ x86-64 Base64 ഡീകോഡർ റൂട്ടീനിലെ ഒരു ബഗ് ആണിത്. 65 പ്രതീകങ്ങളുള്ള ഒരു ഇൻപുട്ട് 50-ബൈറ്റ് അറേയിലേക്ക് 64 ബൈറ്റുകൾ എഴുതാൻ പ്രേരിപ്പിക്കുന്നുവെന്ന് Calif റിപ്പോർട്ട് ചെയ്യുന്നു, അതിനാൽ 62 ബൈറ്റുകൾ അവസാനത്തിനുശേഷം എത്തുന്നു. Java പിന്നീട് IllegalArgumentException നൽകുന്നു, പക്ഷേ എഴുത്ത് ഇതിനകം സംഭവിച്ചു, അതുകൊണ്ടാണ് അടുത്തുള്ള ഒബ്ജക്റ്റുകൾക്ക് കേടുപാടുകൾ സംഭവിക്കാൻ സാധ്യതയുള്ളത്.

### ഏത് Java പതിപ്പുകൾ, CPU-കൾ, സെർവറുകൾ എന്നിവയെ CVE-2026-114938 ബാധിക്കുന്നു?

OpenJDK-യുടെ ഉപദേശം Java 17, 21, 25, 27 ബിൽഡുകളെ അടയാളപ്പെടുത്തുന്നു. Intel Ice Lake അല്ലെങ്കിൽ അതിനുശേഷമുള്ളവയും AMD Zen 4 അല്ലെങ്കിൽ അതിനുശേഷമുള്ളവയും പോലുള്ള AVX-512 VBMI ഉള്ള x86-64 CPU ആവശ്യമാണെന്ന് Calif-ഉം Red Hat-ഉം പറയുന്നു. ARM64 ബാധിക്കപ്പെടുന്നില്ല, സ്റ്റാൻഡേർഡ് Java 8, 11 എന്നിവ ഈ CVE-യിൽ ഇല്ല. കംപൈലർ ഡീകോഡറിനെ ചൂടാക്കിയിരിക്കുകയും വേണം.

### Java4Shell-നെക്കുറിച്ച് എന്താണ് സ്ഥിരീകരിച്ചത്, എന്താണ് Calif-ന്റെ മാത്രം അവകാശവാദം?

OpenJDK-യും Oracle-യും CVSS 3.1 8.1-ൽ CVE സ്ഥിരീകരിക്കുന്നു, Oracle JDK 17.0.21.1 നവംബർ 17-ന് പുറത്തിറങ്ങി, CISA പാച്ചിംഗ് ആവശ്യപ്പെട്ടു. Calif-ന്റെ ഫലങ്ങൾ അവരുടെ സ്വന്തം പരിശോധനകളാണ്: പതിനൊന്ന് ഉൽപ്പന്നങ്ങളിൽ കോഡ് എക്സിക്യൂഷൻ, CVSS 4.0-ൽ 9.2 സ്കോർ, ഏകദേശം മൂന്ന് മണിക്കൂർ AI പ്രയത്നം. Calif ഉൽപ്പന്ന പാചകക്കുറിപ്പുകൾ രഹസ്യമായി സൂക്ഷിക്കുന്നു, പരിശോധിച്ചപ്പോൾ CVE CISA-യുടെ അറിയപ്പെടുന്ന ചൂഷണം ചെയ്ത ലിസ്റ്റിൽ ഉണ്ടായിരുന്നില്ല.

### എന്റെ സെർവറുകൾ എങ്ങനെ പരിശോധിക്കാം, Java4Shell ഇന്ന് എങ്ങനെ പരിഹരിക്കാം?

നിങ്ങളുടെ വെണ്ടറിൽ നിന്ന് ഒരു ഫിക്സ് ചെയ്ത ബിൽഡിലേക്ക് അപ്ഡേറ്റ് ചെയ്യുക. അതുവരെ JVM -XX:-UseBASE64Intrinsics ഉപയോഗിച്ച് ആരംഭിക്കുക, ഇത് എല്ലാ ചിപ്പുകളിലും പ്രവർത്തിക്കുന്നു, Calif-ഉം Adoptium-ഉം അനുസരിച്ച്. Linux-ൽ, Calif-ന്റെ grep ലൈൻ നാല് CPU ഫ്ലാഗുകൾ പ്രിന്റ് ചെയ്യുന്നു, avx512f, avx512bw, avx512vbmi, bmi2; ഒരു മെഷീൻ പരിധിയിൽ വരാൻ ഈ നാലെണ്ണവും ഉണ്ടായിരിക്കണം. കണ്ടെയ്നർ ചിത്രങ്ങൾ വീണ്ടും നിർമ്മിക്കുക, കാരണം പഴയ ചിത്രത്തിലെ Java പഴയതായി തുടരും.

### Java4Shell-നെക്കുറിച്ചുള്ള വിധി എന്തായിരുന്നു?

The Daily Diff-ന്റെ വിധി SHIP IT എന്നായിരുന്നു. പാച്ച് ചെറിയതും പൊതുവായതും പ്രധാന വെണ്ടർമാർ ഇതിനകം നിർമ്മിച്ചതും ഒരു സ്റ്റാർട്ടപ്പ് ഫ്ലാഗ് എല്ലായിടത്തും പ്രവർത്തിക്കുന്നതുമായതിനാൽ പാച്ച് ഷിപ്പ് ചെയ്യുക. Calif-ന്റെ കോഡ് എക്സിക്യൂഷൻ അവകാശവാദങ്ങൾ മറ്റാരെങ്കിലും അവ കാണിക്കുന്നതുവരെ Calif-ന്റെതായി തുടരും, അതിനാൽ പരിഭ്രാന്തരാകാതെ അപ്ഡേറ്റ് ചെയ്യുക.

## അധ്യായങ്ങൾ

- 0:00 മെമ്മറി സുരക്ഷിതമായ ഒരു ഭാഷയ്ക്ക് എങ്ങനെ അതിർത്തികൾക്ക് പുറത്ത് എഴുതാൻ കഴിയും?
- 0:26 എന്താണ് Java4Shell?
- 1:06 ആരാണ് ഇത് കണ്ടെത്തിയത്, എത്ര വേഗത്തിൽ?
- 1:27 64 A-കൾ എങ്ങനെ ഒരു 50-ബൈറ്റ് അറേയെ കവിഞ്ഞൊഴുകുന്നു?
- 2:03 എന്തുകൊണ്ടാണ് പിശക് സന്ദേശം വളരെ വൈകി എത്തുന്നത്?
- 2:14 ഒരു സ്പിൽ എങ്ങനെ കോഡ് എക്സിക്യൂഷനായി മാറുന്നു?
- 3:01 എന്താണ് സ്ഥിരീകരിച്ചത്, എന്താണ് കലിഫിന്റെ മാത്രം അവകാശവാദം?
- 3:29 നിങ്ങളുടെ ഏത് സെർവറുകൾക്ക് തകരാറിലായ കോഡ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും?
- 4:00 ഇന്ന് നിങ്ങൾ എന്താണ് മാറ്റുന്നത്?
- 4:43 Java4Shell-നെക്കുറിച്ചുള്ള വിധി എന്താണ്?

## വിവർത്തനം ചെയ്ത ട്രാൻസ്ക്രിപ്റ്റ്

യഥാർത്ഥ ഇംഗ്ലീഷ് ആഖ്യാനത്തിൽ നിന്ന് വിവർത്തനം ചെയ്തത്. ലഭ്യമായ ഓഡിയോയും അടിക്കുറിപ്പുകളും YouTube നിയന്ത്രിക്കുന്നു.

### മെമ്മറി സുരക്ഷിതമായ ഒരു ഭാഷയ്ക്ക് എങ്ങനെ അതിർത്തികൾക്ക് പുറത്ത് എഴുതാൻ കഴിയും?

0:00 Java ഒരു മെമ്മറി-സുരക്ഷിത ഭാഷയാണ്. അറുപത്തിനാല് അക്ഷരം 'A'കളും ഒരു സമചിഹ്നവും ഒരു അറേയുടെ അവസാനത്തിന് അറുപത്തിരണ്ട് ബൈറ്റുകൾക്കപ്പുറം എഴുതിച്ചു. ഈ വീഡിയോയിൽ, ഒരു മെമ്മറി-സുരക്ഷിത ഭാഷ എങ്ങനെയാണ് ഇത് ചെയ്യുന്നത്? എന്തുകൊണ്ടാണ് പിശക് സന്ദേശം വളരെ വൈകി എത്തുന്നത്? നിങ്ങളുടെ സെർവറുകളിൽ ഇന്ന് നിങ്ങൾ എന്താണ് മാറ്റുന്നത്? കൂടാതെ, നിങ്ങളുടെ ഏത് സെർവറുകൾക്ക് തകരാറിലായ കോഡ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും? ഒരു ഷെൽ കമാൻഡ് ഇതിൽ മിക്കതിനും ഉത്തരം നൽകുന്നു, വിധിക്ക് മുമ്പ് ഞാൻ നിങ്ങളെ അത് കാണിക്കും.

0:22 ഇത് ബുധനാഴ്ച, നവംബർ പതിനെട്ട്, ഇത് The Daily Diff.

### എന്താണ് Java4Shell?

0:26 Corretto, Temurin, Oracle-ന്റെ ബിൽഡുകൾ എല്ലാം വരുന്ന ഓപ്പൺ സോഴ്സ് Java റൺടൈമായ OpenJDK-യിലെ ഒരു ബഗിന്റെ വിളിപ്പേരാണ് Java4Shell. ഒരു സുരക്ഷാ ഗവേഷണ സംഘമായ Calif, ലോഗിനുകൾക്കും ഫയൽ അപ്‌ലോഡുകൾക്കും പിന്നിലുള്ള ടെക്സ്റ്റ് ഫോർമാറ്റായ Base64 ഡീകോഡ് ചെയ്യുന്ന കോഡിൽ ഇത് കണ്ടെത്തി. OpenJDK-യും Oracle-യും ചൊവ്വാഴ്ച ഫിക്സുകൾ പ്രസിദ്ധീകരിച്ചു. ഇവിടെയുണ്ട് ഹ്രസ്വമായ ഉത്തരം. Java മെമ്മറി സുരക്ഷിതമാണ്, പക്ഷേ അതിനടിയിലുള്ള റൺടൈമിന് C, C++ കൂടാതെ കൈകൊണ്ട് എഴുതിയ അസംബ്ലിയും ഉണ്ട്, ആ ഭാഗം സുരക്ഷിതമല്ല.

0:53 ഒരു പ്രോഗ്രാം Base64 വേണ്ടത്ര തവണ ഡീകോഡ് ചെയ്താൽ, കംപൈലർ ഒരു അസംബ്ലി റൂട്ടീനിലേക്ക് മാറുന്നു, ഇത് പാഡ് ചെയ്ത അറ്റം തെറ്റായി കണക്കാക്കുന്നു. ഇതിന് AVX-512 ഉള്ള ഒരു Intel അല്ലെങ്കിൽ AMD ചിപ്പ് ആവശ്യമാണ്, കൂടാതെ ഒരു സ്റ്റാർട്ടപ്പ് ഫ്ലാഗ് ഇത് ഓഫാക്കുന്നു.

### ആരാണ് ഇത് കണ്ടെത്തിയത്, എത്ര വേഗത്തിൽ?

1:06 Calif-ലെ Quang Luong, Codex കോഡിംഗ് ഏജന്റിനോട് കംപൈലർ, ക്രിപ്റ്റോ, പൊതുവായ ലൈബ്രറികൾ എന്നിവ ഓഡിറ്റ് ചെയ്യാൻ പറഞ്ഞു. തിരിച്ചുവന്നവയിൽ മിക്കതും മാലിന്യമായിരുന്നു, അദ്ദേഹം പറയുന്നു, പിന്നീട് അത് Base64 ഡീകോഡറിനെ ഫ്ലാഗ് ചെയ്തു. ഇത് കണ്ടെത്താൻ ഒരു മണിക്കൂറും ഒരു എക്സ്പ്ലോയിറ്റ് നിർമ്മിക്കാൻ രണ്ട് മണിക്കൂറും എടുത്തുവെന്ന് Calif പറയുന്നു, ഇരുനൂറ് ഡോളറിൽ താഴെ ടോക്കണുകൾക്ക്. കഴിഞ്ഞ മാസം ഞാൻ കവർ ചെയ്ത PHP2Shell-ന്റെ അതേ ടീം.

### 64 A-കൾ എങ്ങനെ ഒരു 50-ബൈറ്റ് അറേയെ കവിഞ്ഞൊഴുകുന്നു?

1:27 Base64 മൂന്ന് ബൈറ്റുകളെ നാല് പ്രതീകങ്ങളായി പാക്ക് ചെയ്യുന്നു, അതിനാൽ അറുപത്തിനാല് 'A'കൾ നാൽപ്പത്തിയെട്ട് ബൈറ്റുകളായി ഡീകോഡ് ചെയ്യപ്പെടുന്നു. പാഡിംഗിനായി സമചിഹ്നം ചേർക്കുക, Java ഉത്തരത്തിനായി അമ്പത് ബൈറ്റ് അറേ റിസർവ് ചെയ്യുന്നു. അസംബ്ലി ആ ടെയിൽ ഒരു അറുപത്തിനാല് ബൈറ്റ് സ്റ്റോർ ഉപയോഗിച്ച് പൂർത്തിയാക്കുന്നു, ഒപ്പം ഏത് ബൈറ്റുകൾ സൂക്ഷിക്കണം എന്ന് പറയുന്ന ഒരു മാസ്കും ഉപയോഗിക്കുന്നു. ഇവിടെ ലെങ്ത് കണക്ക് പൂജ്യത്തിൽ എത്തുന്നു, പാഡിംഗ് ഒരെണ്ണം കൂടി എടുക്കുന്നു, അങ്ങനെ ലെങ്ത് മൈനസ് ഒന്നായി മാറുന്നു. മാസ്ക് അതിനെ ഒരു വലിയ സംഖ്യയായി വായിക്കുന്നു, അതിനാൽ ഓരോ ബിറ്റും ഓണായി നിലനിൽക്കുന്നു. സ്റ്റോർ അറേയുടെ അറ്റത്തിനടുത്ത് നിന്ന് ആരംഭിച്ച് പൂർണ്ണമായ അറുപത്തിനാല് ബൈറ്റുകൾ എഴുതുന്നു.

1:53 അതിൽ അറുപത്തിരണ്ട് ബൈറ്റുകൾ അറേയുടെ അവസാനത്തിന് അപ്പുറത്തേക്ക് പോകുന്നു, അലോക്കേറ്റർ അടുത്ത് വെച്ച ഏത് ഒബ്ജക്റ്റിലാണോ അത് സംഭവിക്കുന്നത്. തുടർന്ന് ഡീകോഡർ ഇൻപുട്ട് തെറ്റാണെന്ന് ശ്രദ്ധിക്കുകയും ഒരു അപവാദം നൽകുകയും ചെയ്യുന്നു. അപവാദം ശരിയാണ്.

### എന്തുകൊണ്ടാണ് പിശക് സന്ദേശം വളരെ വൈകി എത്തുന്നത്?

2:06 വളരെ വൈകിയുമാണ്. എഴുത്ത് ഇതിനകം സംഭവിച്ചു, അതിനാൽ Java അഭ്യർത്ഥന മാന്യമായി നിരസിക്കുന്നു, അതേസമയം നഷ്ടം ഹീപ്പിൽ ഇരിക്കുന്നു. സ്പിൽ കൂടുതലും ഒരു നിശ്ചിത പാറ്റേണാണ്, അതിനാൽ കലിഫ് ഇത് അടുത്തുള്ള ഒരു അറേയുടെ ലെങ്ത് ഫീൽഡിലേക്ക് ലക്ഷ്യമിടുന്നു.

### ഒരു സ്പിൽ എങ്ങനെ കോഡ് എക്സിക്യൂഷനായി മാറുന്നു?

2:14 ഒരു വലിയ ലെങ്ത് ആ അറേയെ ആക്രമണകാരി തിരഞ്ഞെടുക്കുന്ന ബൈറ്റുകൾ സ്വീകരിക്കാൻ പ്രേരിപ്പിക്കുന്നു. പ്രതികരിക്കുന്നതിലേക്ക് പകർത്തുന്ന രണ്ടാമത്തെ അറേയിലേക്ക് ഇത് വീണ്ടും ചെയ്യുക, അങ്ങനെ ഹീപ്പ് മെമ്മറി തിരിച്ചുവരുന്നു. കലിഫ് ഇതിനെ Heartbleed ശൈലി എന്ന് വിളിക്കുന്നു. അവിടെ നിന്ന്, കലിഫ് പറയുന്നത്, പതിനൊന്ന് ജനപ്രിയ Java ഉൽപ്പന്നങ്ങളിൽ കോഡ് എക്സിക്യൂഷൻ അവർക്ക് ലഭിച്ചു എന്നാണ്. Keycloak, Jira, Jenkins എന്നിവയുൾപ്പെടെ ആറെണ്ണത്തിന് ലോഗിൻ ആവശ്യമില്ലായിരുന്നു. Kafka, Elasticsearch എന്നിവയുൾപ്പെടെ അഞ്ചെണ്ണത്തിന് ലോഗിൻ ആവശ്യമായിരുന്നു. ഇത് Calif-ന്റെ സ്വന്തം പരിശോധനകളാണ്, ഡിഫോൾട്ട് സജ്ജീകരണങ്ങളിൽ.

2:42 ആളുകൾ പാച്ച് ചെയ്യുന്നതുവരെ അവർ പാചകക്കുറിപ്പുകൾ രഹസ്യമായി സൂക്ഷിക്കുന്നു. Calif പരിമിതികളെക്കുറിച്ച് തുറന്നു പറയുന്നു. സാർവത്രിക എക്സ്പ്ലോയിറ്റ് ഇല്ല. ഓരോ ഉൽപ്പന്നത്തിനും അതിൻ്റേതായ പാചകക്കുറിപ്പ് ആവശ്യമാണ്, സമയക്രമം നെറ്റ്‌വർക്ക് ജിറ്ററിനോട് സംവേദനക്ഷമമാണ്, കൂടാതെ ജിറ്ററിനുള്ള അവരുടെ പരിഹാരം ടാർഗെറ്റിന്റെ അതേ ക്ലൗഡ് മേഖലയിൽ ഒരു സെർവർ വാടകയ്‌ക്കെടുക്കുക എന്നതായിരുന്നു. ഭൗതികശാസ്ത്രം, കൂടാതെ പണം. Calif-ന് പുറത്ത്, ഇവിടെ സ്ഥിരീകരിച്ചവ.

### എന്താണ് സ്ഥിരീകരിച്ചത്, എന്താണ് കലിഫിന്റെ മാത്രം അവകാശവാദം?

3:01 OpenJDK-യും Oracle-യും ബഗിനെ 8.1 എന്ന് ലിസ്റ്റ് ചെയ്യുന്നു, പുതിയ സ്കെയിലിൽ Calif 9.2 എന്ന് പറയുന്നു. പൊതുവായ നവംബർ സുരക്ഷാ ശാഖയിലെ നാല് വരി മാറ്റത്തിന് 'Base64 ഒപ്റ്റിമൈസേഷൻ മെച്ചപ്പെടുത്തലുകൾ' എന്ന് തലക്കെട്ട് നൽകിയിരിക്കുന്നു. ആ തലക്കെട്ടിൽ സുരക്ഷ എന്ന് പറയുന്നില്ല. Cisa പാച്ചിംഗ് ആവശ്യപ്പെട്ടു, ഞാൻ പരിശോധിച്ചപ്പോൾ, ബഗ് അതിന്റെ അറിയപ്പെടുന്ന ചൂഷണം ചെയ്ത ലിസ്റ്റിൽ ഉണ്ടായിരുന്നില്ല. സുരക്ഷാ സ്ഥാപനമായ Hadrian പറയുന്നത്, ഒരു ലാബിൽ ലോഗിൻ പരിശോധനകൾ തകരുകയും ഒരു ലാബ് സർവീസിൽ കോഡ് പ്രവർത്തിപ്പിക്കുകയും ചെയ്തു എന്നാണ്. ഇനി നിങ്ങളുടെ സെർവറുകൾ.

3:27 നാല് കാര്യങ്ങൾ ഒത്തുചേരണം.

### നിങ്ങളുടെ ഏത് സെർവറുകൾക്ക് തകരാറിലായ കോഡ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും?

3:29 AVX-512 VBMI ഉള്ള ഒരു ചിപ്പ്, അതായത് Intel Ice Lake മുതൽ അല്ലെങ്കിൽ AMD Zen 4 മുതൽ. Graviton പോലുള്ള ARM മെഷീനുകൾ പുറത്താണ്. Java പതിനേഴോ അതിനുശേഷമുള്ളതോ, Oracle-ന്റെ Java എട്ട് പെർഫോമൻസ് ബിൽഡും കണക്കിലെടുക്കണം. കംപൈലർ ചൂടാക്കിയ ഒരു ഡീകോഡർ. കൂടാതെ ഒരു ആക്രമണകാരിക്ക് എത്താൻ കഴിയുന്ന ഇൻപുട്ടും. ഞാൻ വാഗ്ദാനം ചെയ്ത പരിശോധന ഇതാ. ഈ വരി നാല് CPU ഫ്ലാഗുകൾ പ്രിന്റ് ചെയ്യുന്നു, കൂടാതെ ഒരു മെഷീൻ അവിടെ റൂട്ടീൻ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് ഈ നാലെണ്ണവും ആവശ്യമാണ്.

3:49 ഒരെണ്ണം കാണുന്നില്ലെങ്കിൽ, നിങ്ങൾ ഈ ബഗിന്റെ പരിധിക്ക് പുറത്താണ്, എങ്കിലും നിങ്ങൾ അപ്ഡേറ്റ് ചെയ്യണം. ഓരോ Java ലൈനിനും ഒരു പുതിയ ബിൽഡാണ് പരിഹാരം. Oracle ചൊവ്വാഴ്ച ഒന്ന് അയച്ചു, Corretto-യ്ക്ക് അതിന്റെ ബിൽഡുകൾ ഉണ്ട്, Temurin പുറത്തിറങ്ങുന്നു. നിങ്ങൾ അപ്ഡേറ്റ് ചെയ്യുന്നതുവരെ, മൈനസ് X X കോളം മൈനസ് Use Base64

### ഇന്ന് നിങ്ങൾ എന്താണ് മാറ്റുന്നത്?

4:00 Intrinsics ഉപയോഗിച്ച് Java ആരംഭിക്കുക, ഇത് എല്ലാ ചിപ്പുകളിലും പ്രവർത്തിക്കുന്നു. മറ്റൊരു ഫ്ലാഗായ, Use AVX = 2, ARM മെഷീനുകൾ ആരംഭിക്കുന്നത് തടയുന്നു. കണ്ടെയ്നർ ചിത്രങ്ങളും വീണ്ടും നിർമ്മിക്കുക. ഞാൻ ഇത് പറയുന്നത് കേൾക്കുന്നതിനുപകരം ഇത് വായിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, എല്ലാ ദിവസവും രാവിലെ നിങ്ങളുടെ ഇൻബോക്സിൽ diff എത്തുന്നു, daily diff dot dev-ൽ സൗജന്യമായി, ലിങ്ക് താഴെ. Calif-ന്റെ പാഠം കാര്യങ്ങൾ ഇല്ലാതാക്കുക എന്നതാണ്. വേഗതയേറിയ ഡീകോഡർ Base64-ന്റെ വലിയ അളവുകൾ ഡീകോഡ് ചെയ്യുന്ന പ്രോഗ്രാമുകളെ സഹായിക്കുന്നു,

4:29 മറ്റെല്ലാവരും അത് കൊണ്ടുപോയിരുന്നു. അവർ ശുചീകരണത്തെ വൈബ്-അൺകോഡിംഗ് എന്ന് വിളിക്കുന്നു, ഒരു യഥാർത്ഥ സുരക്ഷാ പേജിലെ ഒരു യഥാർത്ഥ വാചകം. അതിനാൽ ഇന്നത്തെ വിധി SHIP IT ആണ്. പാച്ച് ചെറിയതും പൊതുവായതും പ്രധാന വെണ്ടർമാർ ഇതിനകം നിർമ്മിച്ചതും ഒരു ഫ്ലാഗ് എല്ലായിടത്തും പ്രവർത്തിക്കുന്നതുമായതിനാൽ ഞാൻ അത് ഷിപ്പ് ചെയ്യും. Calif-ന്റെ കോഡ് എക്സിക്യൂഷൻ അവകാശവാദങ്ങൾ മറ്റാരെങ്കിലും അവ കാണിക്കുന്നതുവരെ Calif-ന്റെതായി തുടരും, അതിനാൽ പരിഭ്രാന്തരാകരുത്, അപ്ഡേറ്റ് ചെയ്യുക.

### Java4Shell-നെക്കുറിച്ചുള്ള വിധി എന്താണ്?

4:45 സബ്സ്ക്രൈബ് ചെയ്യുക, ബെൽ അടിക്കുക, നിങ്ങൾ ഇത് വ്യത്യസ്തമായി സ്റ്റാമ്പ് ചെയ്യുമായിരുന്നോ എന്ന് കമന്റുകളിൽ എന്നോട് പറയുക. അതാണ് ഇന്നത്തെ diff. ഞാൻ Axrisi-ൽ നിന്നുള്ള Niko. ഉത്തരവാദിത്തത്തോടെ ലയിപ്പിക്കുക. ദയവായി ശ്രദ്ധിക്കുക: നൽകിയിട്ടുള്ള വിവരങ്ങൾ സംഗ്രഹിച്ചതും വിവരദായകമായതുമാണ്, ഒരു ഔദ്യോഗിക സുരക്ഷാ റിപ്പോർട്ടായി ഇതിനെ കണക്കാക്കരുത്. ഇവിടെ പറഞ്ഞിരിക്കുന്ന എല്ലാ സാങ്കേതിക വിവരങ്ങളും യഥാർത്ഥ ഉറവിടങ്ങളിൽ നിന്ന് സ്വയം സ്ഥിരീകരിക്കേണ്ടതാണ്. സുരക്ഷാ പാച്ചുകൾ ഉടൻ തന്നെ നടപ്പിലാക്കാൻ ശുപാർശ ചെയ്യുന്നു. നിങ്ങളുടെ സിസ്റ്റങ്ങളുടെ സുരക്ഷ ഉറപ്പാക്കുന്നതിന് വിദഗ്ദ്ധോപദേശം തേടുന്നത് ഉചിതമാണ്.

## ഉറവിടങ്ങൾ

- [Java4Shell: Write once, RCE everywhere](https://calif.io/java4shell) — Calif.io (Quang Luong)
- [OpenJDK Vulnerability Advisory: 2026/11/17](https://openjdk.org/groups/vulnerability/advisories/2026-11-17) — OpenJDK
- [Oracle Critical Security Patch Update Advisory - November 2026](https://www.oracle.com/security-alerts/cspunov2026.html) — Oracle
- [Merge CSPU26\_11 into master (PR 33936)](https://github.com/openjdk/jdk/pull/33936) — OpenJDK / GitHub
- [Critical Java Vulnerability Requires Immediate Patching](https://www.cisa.gov/news-events/alerts/2026/11/17/critical-java-vulnerability-requires-immediate-patching) — CISA
- [Known Exploited Vulnerabilities catalog (checked November 18, 2026)](https://www.cisa.gov/known-exploited-vulnerabilities-catalog) — CISA
- [RHSB-2026-018: java4shell](https://access.redhat.com/security/vulnerabilities/RHSB-2026-018) — Red Hat
- [Eclipse Temurin guidance for CVE-2026-114938](https://adoptium.net/news/2026/11/temurin-november-2026-cspu-java4shell) — Adoptium
- [Corretto 25.0.5.1.2 changelog](https://github.com/corretto/corretto-25/blob/25.0.5.1.2/CHANGELOG.md) — Amazon Corretto
- [CVE-2026-114938](https://explore.alas.aws.amazon.com/CVE-2026-114938.html) — Amazon Linux Security Center
- [JDK 17.0.21.1 Release Notes](https://www.oracle.com/java/technologies/javase/17-0-21-1-relnotes.html) — Oracle
- [Java4Shell (CVE-2026-114938): pre-auth memory corruption in OpenJDK](https://hadrian.io/vulnerability-alerts/oracle-critical-security-patch-update-java-17-rce-claims) — Hadrian
- [Java4Shell: RCE in OpenJDK when processing Base64](https://news.ycombinator.com/item?id=50538240) — Hacker News
