Coding Gun

PHP2Shell คืออะไร? ช่องโหว่ใน PHP Runtime ที่ฝังมานาน 14 ปี

PHP2Shell คือชื่อเรียกช่องโหว่ร้ายแรงที่เกิดขึ้นใน PHP Runtime ซึ่งเป็นหนึ่งในปัญหาด้านความปลอดภัยที่ใหญ่ที่สุดของปีนี้ ความน่ากลัวของมันคือปัญหาไม่ได้อยู่ในโค้ดที่เราเขียน แต่อยู่ในตัว PHP เอง ทำให้ส่งผลกระทบเป็นวงกว้าง เพราะเว็บไซต์ทั่วโลกประมาณ 70% สร้างขึ้นด้วย PHP ไม่ว่าคุณจะใช้ PHP ผ่าน CMS อย่าง WordPress, Drupal, Joomla หรือเขียน PHP เองก็ตาม ก็อาจได้รับผลกระทบจากช่องโหว่นี้

PHP2Shell ช่องโหว่ระดับ PHP Runtime ที่อยู่ใต้ Application ทุกตัว ไม่ว่าจะเป็น CMS, Shop, Blog หรือ API
PHP2Shell — Critical PHP Runtime Vulnerabilities

PHP Runtime อยู่ตรงไหน?

ก่อนจะไปดูช่องโหว่ เรามาดูก่อนว่า PHP Runtime อยู่ตรงไหนในการทำงานของ Web Application

  1. Client ส่ง Request เข้ามา
  2. Web Server รับ Request นั้นไว้ โดยปกติ Web Server จะให้บริการเฉพาะไฟล์ที่เป็น Static เช่น HTML, Stylesheet และ JavaScript
  3. ถ้าต้องการการทำงานแบบ Dynamic เราจะใช้ Runtime ที่อยู่ด้านหลัง ซึ่ง PHP ก็เป็นหนึ่งในทางเลือกนั้น
  4. PHP Runtime ทำหน้าที่ Render ผลลัพธ์ Query ข้อมูลจากฐานข้อมูล หรือประมวลผลอื่นๆ แล้วส่งผลลัพธ์กลับไปให้ Client

ตำแหน่งของ PHP Runtime ระหว่าง Web Server กับ Application และความต่างระหว่าง Bug ในปลั๊กอินกับ Bug ใน PHP Runtime
PHP Runtime อยู่ตรงไหน?

ช่องโหว่ PHP2Shell เกิดขึ้นที่ PHP Runtime ไม่เกี่ยวข้องกับ Application Code เลย ดังนั้นไม่ว่าเราจะเขียนโค้ดดีแค่ไหน ช่องโหว่นี้ก็ส่งผลกระทบกับเราทันที

เราไม่สามารถแก้ปัญหานี้ด้วยการอัปเดต WordPress, Drupal หรือ Joomla ได้ เราจำเป็นต้องอัปเดต PHP เท่านั้น

PHP2Shell คืออะไร?

PHP2Shell ประกอบด้วยช่องโหว่ 2 รายการ คือ

  1. CVE-2026-109618 ปัญหา Out-of-Memory Corruption (การจัดการ Memory ผิดพลาดเมื่อเกิด Out of Memory)
  2. CVE-2026-109619 ปัญหา Stale Global State หรือ Use-After-Free

ทั้งสองเป็นปัญหาด้าน Memory Safety ที่ผู้โจมตีไม่จำเป็นต้องยืนยันตัวตน (Unauthenticated) และผลลัพธ์ที่อาจเกิดขึ้นได้คือการเปิดเผยข้อมูลที่อยู่ใน Memory (Remote Memory Disclosure) หรือร้ายแรงถึงขั้น Remote Code Execution (RCE)

PHP2Shell แบ่งเป็น CVE-2026-109618 (Out-of-memory corruption) และ CVE-2026-109619 (Stale global state / use-after-free)
PHP2Shell คืออะไร?

PHP Worker ทำงานอย่างไร?

ก่อนจะเข้าใจช่องโหว่ เราต้องรู้จัก PHP Worker ก่อน ถ้า PHP มี Runtime เพียงตัวเดียวรองรับ Load ทั้งหมด ระบบก็มีโอกาส Down ได้ง่าย PHP จึงแบ่งการทำงานออกเป็น Worker หลายตัว เพื่อให้ Application ทำงานได้เร็วขึ้น

  1. Client ส่ง Request เข้ามาที่ Web Server
  2. Web Server ส่ง Request ต่อไปยัง Worker (เช่น ผ่าน PHP-FPM ที่มี master process คอยจัดการกลุ่ม Worker)
  3. Worker ประมวลผลแล้วส่งผลลัพธ์กลับไป

Worker ทั้งหมดจะทำงานอยู่ใน Worker Pool และ Worker ตัวเดิมอาจถูกใช้รองรับ Request ถัดๆ ไป โดยมี Config pm.max_requests เป็นตัวกำหนดนโยบายการ Recycle Worker

PHP Worker ใน Worker Pool รับ Request ต่อจาก Web Server ผ่าน PHP-FPM
PHP Worker ทำงานอย่างไร?

ปัญหาของ PHP2Shell เกิดจากการจัดการ State ของ Worker ระหว่าง Request

ผลกระทบแบบที่ 1: Remote Memory Disclosure

Remote Memory Disclosure คือการที่ Attacker สามารถอ่านข้อมูลออกไปจาก Memory ได้ โดย Attacker ส่ง Request เข้ามาที่ PHP แล้วช่องโหว่ทำให้ PHP อ่าน Memory ใน Address ที่ไม่ควรอ่าน ซึ่งอาจเกิดจากการจอง Memory มากเกินไป หรือปริมาณข้อมูลไม่สอดคล้องกับขนาดที่จองไว้ ผลคือข้อมูลใน Memory ของ Process หลุดออกไปพร้อมกับ Response

คำว่า Remote หมายความว่าการโจมตีนี้ทำได้จากที่ไหนก็ได้ ซึ่งถือว่าเป็นปัญหาที่รุนแรงมาก

Remote Memory Disclosure: Attacker ส่ง Request แล้วได้ข้อมูลจาก PHP process memory กลับไปใน Response
Remote Memory Disclosure

ผลกระทบแบบที่ 2: Remote Code Execution (RCE)

Remote Code Execution คือการที่ Attacker ส่ง Command เข้ามาผ่าน Input หรือผ่านช่องโหว่ต่างๆ แล้วทำให้ Command นั้นถูก Execute บน Server นั่นหมายความว่า Attacker สามารถครอบครองเครื่องนั้นได้ทันที

Command ที่ถูก Execute จะทำงานด้วยสิทธิ์ของ Process นั้น ซึ่งโดยทั่วไปจะเป็น User www-data ที่ใช้รองรับการทำงานของ Web Server ดังนั้นการกำหนดสิทธิ์ในการเข้าถึง File, Credential, Database หรือ Service ต่างๆ ต้องทำอย่างระมัดระวัง

ถ้า www-data มีสิทธิ์สูงเกินไป Attacker ก็จะเข้าถึง Resource อื่นๆ ต่อได้ง่าย นี่คือเหตุผลที่ Least Privilege (ให้สิทธิ์เท่าที่จำเป็น) ยังสำคัญเสมอ

RCE: Code ของผู้ใช้ภายนอกรันบน Server ด้วยสิทธิ์ของ process (www-data) และเข้าถึง Files, Credentials, Database, Internal services
Remote Code Execution (RCE)

CVE-2026-109618: Out of Memory

ช่องโหว่แรกเกิดจากการจัดการ Memory ที่ไม่ดีเมื่อเกิด Out of Memory โดยปกติแต่ละ PHP Request จะมีขีดจำกัดการใช้ Memory ตาม Configuration memory_limit และการทำงานของ Request จะมี 3 ขั้นตอน คือ

  1. Request start รับ Request เข้ามาประมวลผล
  2. Prepare data จองพื้นที่ในหน่วยความจำเพื่อเก็บข้อมูลที่ถูกส่งเข้ามา
  3. Cleanup คืนพื้นที่เมื่อใช้งานเสร็จ

ปัญหาเกิดขึ้นเมื่อ Request เข้าสู่สถานะ Out of Memory ระหว่างการเตรียมข้อมูล พอเข้าสู่ขั้นตอน Cleanup PHP จะไปอ่านข้อมูลใน Memory Block ที่เกินจาก Limit ไปแล้ว (State ที่ไม่ถูกต้อง) ซึ่งอาจทำให้เกิดการ Execute Code ขึ้นมาได้

CVE-2026-109618: Request ที่ Out of memory ระหว่าง Prepare data ทำให้ขั้น Cleanup ใช้ state ที่ไม่ถูกต้อง
CVE-2026-109618

CVE-2026-109618 สามารถนำไปสู่ Remote Code Execution ได้ แนวทางป้องกันคือพยายามไม่ให้เกิดสถานะ Out of Memory

CVE-2026-109619: Stale Global State / Use-After-Free

PHP Worker จะใช้พื้นที่ที่เรียกว่า Request Memory ซึ่งเป็นพื้นที่แชร์ตรงกลางแบบ Heap ที่ใครก็อ่านและเขียนได้ เมื่อมี Request เข้ามา PHP จะบันทึกข้อมูลโดยอ้างอิงตาม Session ID แล้วเขียนข้อมูลปกติ เช่น ข้อมูลจากฟอร์มหรือไฟล์ที่อัปโหลดลงใน Request Memory

ปัญหาเกิดขึ้นเมื่อ Request ทำงานไม่สมบูรณ์หรือเกิด Error ระหว่างทาง

  1. PHP ลบข้อมูลใน Request Memory ออก แล้วมาร์กพื้นที่นั้นเป็น freed
  2. แต่ Pointer ที่ชี้ไปยัง Address เดิม (เช่น 0x1234) ไม่ได้ถูกลบออกไปด้วย
  3. ที่ถูกต้องคือต้องลบทั้ง Pointer และข้อมูลใน Memory

ปัญหานี้เรียกว่า Stale Global State หรือ Use-After-Free หลักการคือเมื่อ Memory ถูก Free (ยกเลิกการใช้งาน) ไปแล้ว ก็ไม่ควรถูกนำกลับมาใช้ผ่าน Pointer เดิมได้อีก

CVE-2026-109619: Request A เกิด Error, Request memory ถูก freed แต่ Pointer 0x1234 ยังไม่ถูกลบ
Stale Global State = Use-After-Free

เมื่อ Pointer ยังค้างอยู่ จึงเปิดโอกาสให้เกิดผลกระทบได้ 2 แบบ

  1. Remote Code Execution Attacker ส่ง Request ใหม่ใน Session ID เดิม แล้วเขียนข้อมูลที่ใช้โจมตี (Malicious Code) ลงไปใน Request Memory Address เดิมผ่าน Pointer ที่ค้างอยู่
  2. Remote Memory Disclosure เมื่อพื้นที่ถูก Free แล้ว PHP Worker ตัวอื่นก็สามารถ Reuse Memory นั้นได้ เช่น Request B ของ User อีกคนเขียนข้อมูลปกติ (valid data) ลงไป ถ้า Attacker ส่ง Request ขนาดเดิมซ้ำๆ จนได้ Address เดิม Pointer ที่ค้างอยู่ก็จะชี้ไปยังข้อมูลของคนอื่น

CVE-2026-109619: Request B ของ User อื่น reuse Request memory ที่ถูก freed ทำให้ Pointer เดิมชี้ไปยังข้อมูลของคนอื่น
CVE-2026-109619 — Remote Memory Disclosure

ทำไมช่องโหว่นี้จึงสำคัญ?

  1. ไม่ต้อง Login ใครก็ได้ที่รู้ว่าเว็บไซต์หรือแอปพลิเคชันของเราอยู่ที่ไหนก็โจมตีได้ทันที จึงเป็นช่องโหว่ที่ต้อง Patch
  2. ไม่เกี่ยวกับ Source Code ต่อให้ Application มีแค่ echo "Hello World" ก็ได้รับผลกระทบเหมือนกัน
  3. ฝังมานานตั้งแต่ PHP 5.4 ซึ่งออกมาเมื่อ 14 ปีที่แล้ว นั่นหมายความว่าช่องโหว่นี้อยู่กับเรามาตลอด 14 ปี

ทำไมช่องโหว่นี้จึงสำคัญ: No login required, The flaw is PHP runtime, Every version since PHP 5.4
ทำไมช่องโหว่นี้จึงสำคัญ?

กรณีนี้ทีมวิจัยอย่าง Calif และ Wiz ต่างใช้ AI เข้ามาช่วยในการวิจัย ซึ่งสะท้อนว่าเรากำลังเข้าสู่ยุคที่ AI มีส่วนร่วมในการทดสอบหาช่องโหว่ และเราจะได้เห็นอีกหลายกรณีที่ช่องโหว่ซึ่งฝังมา 10 ปีหรือ 20 ปี เพิ่งถูกค้นพบโดยทีมที่มี AI Agent เป็นผู้ช่วย

ระบบของเราได้รับผลกระทบไหม?

สิ่งที่ควรทำเพื่อประเมินระบบมี 3 ขั้นตอน

  1. Asset Inventory ลิสต์ Server ทั้งหมดออกมาก่อน ว่าอยู่ใน Layer ไหน ไม่ว่าจะเป็น VM, Container, Bare Metal รวมทั้ง Third Party และ Cloud Service ที่เราใช้ แล้วดูว่ามี PHP อยู่ตรงไหนบ้าง
  2. เช็ค PHP Version ของ Server ที่ลิสต์ออกมา ว่าแต่ละตัวรันอยู่บน PHP Runtime เวอร์ชันไหน และดูคำแนะนำของผู้ผลิต (Vendor Advisory) ประกอบ
  3. เช็ค Backport ถ้าเราใช้ PHP จาก Vendor หรือ Third Party ที่ Customize PHP เอง เลขเวอร์ชันอาจไม่ตรงกับ PHP Build ที่เป็น Official เพราะมีการดัดแปลง PHP เวอร์ชันนั้นๆ

ประเมินระบบ: 1 Inventory (Server, VM, Container, Hosting), 2 Version / Vendor advisory, 3 Check backports
ระบบของเราได้รับผลกระทบไหม?

เวอร์ชันที่แก้ไขแล้ว

PHP ได้ออกประกาศเวอร์ชันที่แก้ไขช่องโหว่แล้ว ดังนี้

PHP Branch ควรอัปเดตเป็น
PHP 8.5 8.5.12 เป็นต้นไป
PHP 8.4 8.4.27
PHP 8.3 8.3.36
PHP 8.2 8.2.35

ถ้าใช้ PHP ที่เก่ากว่านั้น (8.1 ลงไป) คำแนะนำคือให้อัปเดตเป็นเวอร์ชันล่าสุด คือ 8.5.12 แต่ถ้ายังอัปเดตไม่ได้ ให้ดูคำแนะนำของผู้ผลิตหรือผู้ดูแล Operating System เพื่อลดผลกระทบจากช่องโหว่นี้

ตารางเวอร์ชัน PHP ที่แก้ไขแล้ว: 8.5.12, 8.4.27, 8.3.36, 8.2.35
เวอร์ชันที่แก้ไขแล้ว

Patch อย่างเดียวอาจไม่พอ

หลังจาก Patch เรียบร้อยแล้ว ยังมีสิ่งที่ต้องทำต่อ

  1. Restart Service ต่างๆ ใหม่
  2. Verify Version เช็คว่า PHP ที่ติดตั้งใหม่เป็นเวอร์ชันล่าสุดจริง และเป็น PHP ตัวที่ถูกเรียกใช้งานจริงๆ
  3. Review Logs ตรวจดูว่าปัญหา PHP2Shell เคยเกิดขึ้นกับระบบของเราแล้วหรือยัง เพราะเราอาจ Patch หลังจากที่ถูกโจมตีไปแล้วก็ได้

หลัง Patch: Patch, Restart, Verify version, Review logs และตรวจ Possible compromise
Patch อย่างเดียวอาจไม่พอ

ถ้าพบว่าระบบอาจถูก Compromise หรือถูกโจมตีด้วย PHP2Shell มาก่อนหน้านี้ ให้เข้าสู่กระบวนการ Incident Response ทันที

Temporary Mitigations: ถ้ายังอัปเดต PHP ไม่ได้

หลายองค์กรมีแอปพลิเคชันเก่าที่พัฒนาไว้ก่อน PHP 8.1 และยังอัปเดตไม่ได้ สิ่งที่ทำได้คือลดโอกาสที่จะถูกโจมตี การแก้ Configuration เหล่านี้ไม่ได้ทำให้ปัญหาหายไป แต่ช่วยลดโอกาสเกิดปัญหาได้

Temporary Mitigations 8 ข้อ ตั้งแต่ memory_limit จนถึง expose_php
Temporary Mitigations

  1. memory_limit = -1 โดย Default PHP จะกำหนด memory_limit ไว้ที่ 128 MB ต่อ PHP Worker ทำให้การ Brute Force เพื่ออ่านข้อมูลใน Memory ใช้จำนวน Request ไม่มาก การตั้งเป็น -1 คือการขยายขอบเขตของ Memory ออกไป ซึ่งทำให้ Attacker คาดเดาขนาดของ Memory ได้ยากขึ้น เพราะ Server ปัจจุบันใช้แนวคิด ASLR (Address Space Layout Randomization ที่สุ่ม Address ไปเรื่อยๆ ข้อมูลจึงไม่ได้อยู่เรียงกัน) Attacker จึงต้องได้ข้อมูลจำนวนมากเพื่อ Mapping Layout ของ Memory แต่ข้อเสียคือแอปพลิเคชันจะกิน Memory มากขึ้นและมีโอกาส Down สูงขึ้น ข้อแนะนำในทางปฏิบัติคือให้รัน PHP ใน Container แล้วจึงตั้ง memory_limit เป็น -1 ถ้าใครยังติดตั้ง PHP ไว้บน Server โดยตรง ก็ถือโอกาสนี้ย้ายมาไว้ใน Container ได้เลย
  2. ลด post_max_size ถ้าไม่มีการอัปโหลดไฟล์ก็ตั้งไว้เล็กๆ เช่น 8 MB ถ้ามีการอัปโหลดไฟล์ก็ตั้งตามขนาดไฟล์ที่ใช้งานจริง ไฟล์ที่ใหญ่เกินจะเกิด Error การบังคับให้ไฟล์มีขนาดเล็กทำให้ Attacker ต้องส่ง Request จำนวนมากขึ้นกว่าจะได้ Layout ของ Memory ทั้งหมด และควรกำหนดให้ upload_max_filesize เล็กกว่า post_max_size เพราะ POST หนึ่ง Request ย่อมใหญ่กว่าไฟล์ที่อัปโหลดเข้ามา
  3. ลด max_input_nesting_level การโจมตีช่องโหว่นี้ใช้การส่ง Input ที่เป็น Array ซ้อน Array หลายชั้น ค่า Default ประมาณ 32–64 Level ถือว่าเยอะมาก ถ้าแอปพลิเคชันไม่ได้ใช้ Array ซ้อนกันลึกขนาดนั้นก็จำกัดลงมา การโจมตีจะทำได้ยากขึ้น
  4. session.upload_progress.enabled = 0 Upload Progress เป็นฟีเจอร์ที่ PHP ตอบกลับได้ว่าไฟล์ที่อัปโหลดไปถึงกี่เปอร์เซ็นต์แล้ว โดยแบ่งไฟล์เป็นชิ้นเล็กๆ แล้วส่ง Progress กลับมาทีละชิ้น ฟีเจอร์นี้เป็นจุดที่ทำให้เกิดสถานะ Out of Memory ได้ ถ้าไม่ได้ใช้ก็ควรปิด
  5. fatal_error_backtraces = 0 สำหรับ PHP 8.5 เป็นต้นไป ค่านี้จะทำให้ Error แสดง Trace ออกมา ซึ่งอาจทำให้ Information หรือ Source Code หลุดออกไปภายนอก ข้อนี้ไม่ได้เกี่ยวกับช่องโหว่โดยตรง แต่ช่วยลดโอกาสข้อมูลรั่วไหล
  6. ลด pm.max_requests ทำให้ Worker ถูก Recycle และ Refresh บ่อยขึ้น การโจมตีแบบ Stale Global State ต้องอาศัย State ที่ค้างอยู่เพื่อชี้ไปยังข้อมูลใน Memory จึงทำได้ยากขึ้น แต่ต้องแลกกับ Performance ที่แย่ลง
  7. SELinux / AppArmor เพิ่มความสามารถในการป้องกันให้ Operating System เพื่อลดผลกระทบจาก Remote Code Execution เพราะ Command ที่ถูกส่งเข้ามาจะถูกจำกัดสิทธิ์ และ AppArmor Profile ยังกำหนดได้ว่าคำสั่งไหนใช้ได้หรือไม่ได้ (Whitelist / Blacklist Command)
  8. expose_php = 0 ซ่อนเวอร์ชันของ PHP เมื่อมีคนสแกนเว็บไซต์ของเรา ข้อนี้ไม่ใช่การแก้ปัญหาแน่นอน แต่ถ้ามีข้อจำกัดด้านงบประมาณหรือด้านอื่นๆ อย่างน้อยก็ลดโอกาสที่จะตกเป็นเป้าหมาย

สรุปค่า Configuration ที่กล่าวถึงข้างต้น (ค่าที่เหลือให้ปรับตามการใช้งานจริงของแต่ละระบบ)

; php.ini
memory_limit = -1                  ; ใช้คู่กับการรัน PHP ใน Container
post_max_size = 8M                 ; กรณีไม่มีการอัปโหลดไฟล์
; upload_max_filesize ต้องเล็กกว่า post_max_size
; max_input_nesting_level ลดลงให้เท่าที่แอปใช้จริง
session.upload_progress.enabled = 0
fatal_error_backtraces = 0         ; PHP 8.5 เป็นต้นไป
expose_php = 0

; PHP-FPM pool config
; pm.max_requests ลดลงเพื่อให้ Worker ถูก Recycle บ่อยขึ้น (แลกกับ Performance)

ทั้งหมดนี้เป็น Temporary Mitigation ไม่ใช่การแก้ปัญหา การอัปเดต PHP คือวิธีแก้ที่สมบูรณ์ ควร Patch ให้เร็วที่สุด

สิ่งที่ควรตรวจใน Logs

ไม่ว่าจะ Patch แล้วหรือปรับ Configuration แล้ว สิ่งที่ต้องมีต่อจากนี้คือการ Monitor ว่ามีเหตุการณ์ผิดปกติเกิดขึ้นหรือไม่ เช่น

  1. PHP Worker Crash หรือ Restart ซ้ำๆ
  2. Memory Error ที่เกิดถี่เกินไป
  3. Request ที่ส่งเข้ามาซ้ำๆ ในรูปแบบที่ไม่ใช่การใช้งานปกติ เช่น Array ซ้อนกันหลายชั้น
  4. Child Process ที่ไม่ควรเกิดขึ้น ซึ่งอาจเป็นสัญญาณของ Remote Code Execution
  5. ไฟล์ใหม่ใน Webroot, Scheduled Task หรือ Cron Job โดยเฉพาะที่มีเจ้าของเป็น www-data ซึ่งเป็นสัญญาณผิดปกติอย่างชัดเจน

สิ่งที่ควรตรวจใน Logs: PHP worker crash, Memory errors, Request ผิดปกติ, Unexpected child process, ไฟล์ใหม่ใน web root / scheduled task
สิ่งที่ควรตรวจใน Logs

สัญญาณเหล่านี้ไม่ได้ยืนยันว่าเราถูกโจมตีแล้ว (Indicators ≠ Proof) แต่เป็นสิ่งที่ต้องนำไปวิเคราะห์ต่อว่าความผิดปกติแต่ละข้อเกิดจากอะไร และใช่การโจมตีด้วย PHP2Shell หรือไม่

สรุป

PHP2Shell คือช่องโหว่ที่เกิดจากการจัดการ Memory ใน PHP Runtime ซึ่งฝังอยู่นานถึง 14 ปี และอาจทำให้เกิดปัญหา 2 อย่าง คือ Remote Memory Disclosure และ Remote Code Execution

  1. สิ่งที่ต้องทำคือ Patch หรืออัปเดต PHP เป็นเวอร์ชันที่แก้ไขแล้ว แล้ว Restart, Verify และ Investigate
  2. ถ้ายังอัปเดตไม่ได้ ให้ปรับ Configuration ให้แข็งแรงพอที่จะทำให้การโจมตีเกิดขึ้นได้ยาก
  3. หลังจากนี้ไม่ว่าจะ Patch หรือปรับ Config แล้ว ต้องมีการ Monitor ความผิดปกติที่อาจเกิดขึ้นในอนาคต

สรุป PHP2Shell: Inventory → Patch → Restart → Verify → Investigate
สรุป PHP2Shell

อ่านต่อเพิ่มเติมได้ที่

Phanupong Permpimol
Follow me