Coding Gun

GitLab Critical RCE ช่องโหว่ CVSS 10.0

CVE-2026-110264 คือช่องโหว่ Remote Code Execution(RCE) ใน GitLab ที่มีความรุนแรงสูงสุด คือมี CVSS Score 10 เต็ม 10 ซึ่งต้นเหตุมาจาก Integer Overflow ในขั้นตอนการ Compile Regular Expression และเนื่องจาก GitLab เป็น DevOps Platform ที่ได้รับความนิยมเป็นอันดับต้น ๆ และถูกใช้งานอยู่ในหลายองค์กร ช่องโหว่นี้จึงเป็นเรื่องที่ผู้ดูแลระบบและ Developer ทุกคนที่มี GitLab Server ต้องรู้

GitLab Under Attack ช่องโหว่ CVSS 10.0

GitLab ทำหน้าที่อะไรบ้าง

ก่อนจะไปดูตัวปัญหา เรามาดูกันก่อนว่า GitLab ทำอะไรได้บ้าง

  1. Git Repository เป็นที่เก็บ Source Code โดย Developer จะ Push Code ขึ้นไปไว้ใน Repository
  2. Merge Request เป็นกระบวนการ Version Control ที่มากกว่าแค่การเก็บ Source Code ซึ่งก็คือสิ่งเดียวกับ Pull Request บนแพลตฟอร์มอื่นอย่าง GitHub
  3. CI/CD Pipeline GitLab สามารถสร้าง Pipeline สำหรับ Build, Test และ Deploy ได้ในตัว

แต่ GitLab ไม่ได้ทำงานทุกอย่างด้วยตัวเอง GitLab ทำหน้าที่กำหนด Workflow ส่วนงานจริงอย่างการ Compile, Build, รันเทสต์ หรือสแกนในรูปแบบต่าง ๆ จะถูกส่งไปให้ GitLab Runner ที่คอยรับงานไปทำ ดังนั้น GitLab จึงไม่ได้เป็นแค่ที่เก็บโค้ด แต่เป็น DevOps Platform ขนาดย่อม

GitLab เป็นทั้ง Git Repository, Merge Request, CI/CD Pipeline และ GitLab Runner

ทำไม GitLab ถึงมีของสำคัญอยู่ข้างในเยอะ

ในการทำงานทั่วไป Developer จะ Push Code ขึ้นไปที่ Code Repository บน GitLab จากนั้นจะ Trigger ให้ Pipeline เริ่มทำงาน ซึ่งส่วนใหญ่จะเริ่มจาก Build Pipeline ก่อน แล้ว Pipeline ก็จะสร้าง Job กระจายลงไปให้ GitLab Runner เพื่อทดสอบหรือ Deploy Application ออกไป

เพราะทำหน้าที่เป็นศูนย์กลางของทั้งกระบวนการ GitLab จึงต้องเก็บของสำคัญไว้ข้างในหลายอย่าง เช่น

  1. Source Code ของแอปพลิเคชัน
  2. Access Token ที่ใช้เชื่อมต่อกับระบบอื่น ๆ
  3. Token ของ GitLab Runner ที่ใช้ควบคุมและบริหารจัดการ Runner
  4. Credential ที่ใช้ในการ Deploy Application

GitLab = ของสำคัญอยู่ข้างในเยอะ ถ้า GitLab ถูกยึด ของเหล่านี้ก็เสี่ยงไปด้วยทั้งหมด

Workflow ของ GitLab ตั้งแต่ Push Code จนถึง Deploy และของสำคัญที่เก็บไว้ใน GitLab

Regex Compiler คือจุดเสี่ยง

ปัญหาของช่องโหว่นี้เกิดขึ้นที่ Regular Expression Compiler(ตัวประมวลผล Regular Expression) โดย Regular Expression คือ Syntax ที่ใช้กำหนด Pattern ของข้อความ ซึ่งถูกใช้อยู่ในหลายจุดของ GitLab

ในตอนนี้ GitLab ยังไม่ได้ระบุว่าปัญหาเกิดจาก Input รูปแบบไหน แต่ก็มีการคาดการณ์ว่าน่าจะเกี่ยวข้องกับส่วนที่ Render เอกสาร Org-mode ออกมาเป็นหน้าเว็บ ภาพรวมของปัญหาเป็นแบบนี้

  1. Attacker ส่ง Input ที่มี Regular Expression ในรูปแบบพิเศษเข้าไปใน GitLab
  2. GitLab ไม่ได้ตีความ Regular Expression เอง จึงส่งต่อไปให้ Engine ตรงกลางคือ Regex Compiler ประมวลผล
  3. ปัญหาเกิดขึ้นที่ Onigmo ซึ่งเป็น Library สำหรับ Compile Regular Expression ที่อยู่ข้างใน
  4. ผลลัพธ์คือเกิด Integer Overflow
  5. เมื่อเกิด Integer Overflow ระบบจะจองพื้นที่หน่วยความจำไว้นิดเดียว แต่ไปเขียนข้อมูลในพื้นที่ที่กว้างกว่านั้น ทำให้ข้อมูลไปทับ Memory ของส่วนอื่น

ซึ่งหมายความว่าคำสั่งหรือข้อมูลที่ถูกส่งเข้ามาสามารถไปอยู่ใน Memory ที่ไม่ใช่ของตัวเองได้ การโจมตีแบบนี้จึงค่อนข้างรุนแรง

Attack Surface ของ GitLab จาก Input ผ่าน Regex Compiler (Onigmo) จนเกิด Integer Overflow

Integer Overflow คืออะไร

Integer Overflow คือผลจากการคำนวณที่ไม่ถูกต้อง เกิดจากการที่เราจองพื้นที่ไว้จำนวนหนึ่ง แต่ค่าที่ใส่เข้าไปเกินกว่าที่พื้นที่นั้นจะเก็บได้

ตัวอย่างเช่น ถ้าเรากำหนดให้ข้อมูลเป็นตัวเลขไม่มีเครื่องหมายบวกลบ(unsigned) ขนาด 8 bit เราจะเก็บค่าได้แค่ 0 ถึง 255

  1. ถ้าเก็บค่า 255 จะได้เป็น 1111 1111
  2. ถ้าบวก 1 เข้าไปจะได้ 256 ซึ่งต้องใช้ 9 bit โดย bit ที่เพิ่มขึ้นมาจะอยู่ด้านหน้า
  3. แต่ bit ที่ 9 ไม่ได้อยู่ในพื้นที่ 8 bit ที่จองไว้ ค่าที่เหลือจึงกลายเป็น 0 ทันที

255 + 1 → 0

หลักการโจมตีก็คือ บวกค่าเพิ่มเข้าไปอีกเล็กน้อยจากค่า Maximum ของพื้นที่นั้น bit ด้านหน้าจะหายไป ทำให้ค่าที่คำนวณได้น้อยกว่าปกติ และเมื่อนำค่าที่น้อยผิดปกตินี้ไปใช้จองพื้นที่ ข้อมูลที่เขียนลงไปจริงก็จะเกินพื้นที่ที่จองไว้ กลายเป็นการ Write ลงไปในพื้นที่หน่วยความจำของส่วนอื่น

Integer Overflow ตัวเลข 8 bit เก็บได้ 0 ถึง 255 และ 255 + 1 กลายเป็น 0

CVE-2026-110264 ทำงานยังไง

ช่องโหว่นี้มีรหัส CVE-2026-110264 เป็นช่องโหว่ประเภท Remote Code Execution โดยภาพรวมของการเกิดปัญหามีดังนี้

  1. Attacker ส่ง Regular Expression เข้ามา
  2. ช่องโหว่อยู่ใน Onigmo ซึ่งเป็น Library ของ Ruby
  3. GitLab Application ส่ง Regular Expression นั้นไป Compile ด้วย Onigmo
  4. Onigmo คำนวณขนาด Memory ที่ต้องใช้ผิด จึงจองพื้นที่น้อยกว่าปกติ
  5. สาเหตุคือ Integer Overflow ที่ค่าเกิน Maximum ไปจนได้ค่าที่น้อยกว่าปกติ
  6. ข้อมูลจึงถูกเขียนลงในพื้นที่หน่วยความจำของส่วนอื่น

และถ้าสิ่งที่ถูกเขียนลงไปในหน่วยความจำนั้นเป็นโค้ด ก็จะกลายเป็นปัญหา Remote Code Execution นั่นเอง

ลำดับการเกิดช่องโหว่ CVE-2026-110264 ทั้ง 6 ขั้นตอน

Remote Code Execution(RCE)

Remote Code Execution คือการที่ Attacker สามารถส่งโค้ดเข้าไปให้ GitLab Server รันคำสั่งได้ เมื่อทำได้แล้ว Attacker อาจจะ

  1. สร้าง Process ใหม่ขึ้นมาบน Server
  2. เข้าถึงไฟล์สำคัญ เช่น อ่าน Secret จากไฟล์ gitlab-secrets.json
  3. อ่าน Source Code ของแอปพลิเคชัน เพราะข้อมูลเหล่านี้ก็เป็นไฟล์ที่วางอยู่บน Server ตามปกติ
  4. เปลี่ยนแปลง Workflow บน Server เช่น แก้ไขไฟล์ .gitlab-ci.yml

นอกจากนี้ผลกระทบยังลามไปถึงระบบอื่นที่อยู่ถัดไปได้ด้วย เพราะ GitLab เก็บ Credential ไว้ข้างใน Attacker จึงใช้ Credential เหล่านั้นโจมตีระบบอื่นต่อได้

Remote Code Execution บน GitLab Server และ Credential ที่ถูกนำไปโจมตีระบบอื่นต่อ

ผลกระทบที่อาจเกิดขึ้น

ถ้า GitLab ถูกยึด ผลกระทบที่อาจเกิดขึ้นมีดังนี้

  1. Source Code รั่วไหล เมื่อ Attacker เห็น Source Code ก็จะเห็นช่องโหว่ที่อยู่ในนั้นด้วย การหาช่องโหว่เมื่อมี Source Code ง่ายกว่าการหาโดยไม่มี Source Code มาก
  2. Credential ถูกขโมย แล้วนำไปโจมตีระบบอื่นที่ GitLab เชื่อมต่ออยู่ เรียกว่า Lateral Movement(การโจมตีต่อไปยังระบบข้างเคียง)
  3. Pipeline ถูกดัดแปลง เช่น เปลี่ยน Workflow ปิดการตรวจสอบ Quality หรือข้ามการทำ Security Scan
  4. Infrastructure ได้รับผลกระทบ ในกรณีที่ใช้ Continuous Deployment จะมี Credential สำหรับ Deploy แอปพลิเคชัน ซึ่งทำให้ Infrastructure ที่เรา Deploy ไปเสี่ยงไปด้วย

GitLab เพียง 1 ตัว อาจทำให้เกิดปัญหากับเครื่องมืออื่น ๆ และ Infrastructure ส่วนอื่น ๆ ตามมาได้

ผลกระทบ 4 ด้านเมื่อ GitLab ถูกยึด

เวอร์ชันที่ได้รับผลกระทบ

ช่องโหว่นี้กระทบทั้ง Community Edition และ Enterprise Edition และเป็นปัญหาจาก Source Code ที่ฝังอยู่มานานแล้ว ตั้งแต่เวอร์ชัน 7 จนถึงเวอร์ชัน 19 ทำให้ Range ที่ได้รับผลกระทบกว้างมาก ใครที่ใช้ GitLab เวอร์ชันเก่าจึงควรรีบอัปเดตอย่างเร่งด่วน โดยควรเป็นเวอร์ชันที่ออกหลังวันที่ 21 ตุลาคม 2026

เวอร์ชันต่ำสุดที่ GitLab แนะนำให้อัปเดตในแต่ละ Release มีดังนี้

เวอร์ชันที่ใช้อยู่ อัปเดตเป็นอย่างน้อย
7 – 18 18.11.13
19.0 19.0.10
19.1 19.1.9
19.2 19.2.9
19.3 19.3.6
19.4 19.4.3
19.5 19.5.1

ถ้าต้องอัปเดตอยู่แล้ว ทางที่ดีที่สุดคืออัปเดตเป็นเวอร์ชันล่าสุดไปเลย แต่ต้องระวังผลกระทบที่อาจเกิดกับการรัน Pipeline ด้วย ซึ่งขั้นตอนที่ควรทำคือ

  1. Check เช็กเวอร์ชันที่ใช้อยู่
  2. Identify ระบุช่องโหว่ที่อาจเกิดขึ้น
  3. Upgrade อัปเกรดหรืออัปเดต
  4. Test ทดสอบอีกรอบ เพื่อให้แน่ใจว่าเวอร์ชันที่ติดตั้งลงไปเป็นเวอร์ชันที่ถูกเรียกใช้งานจริง

เวอร์ชันที่ได้รับผลกระทบและเวอร์ชันที่ควรอัปเดตของ GitLab CE และ EE

ตรวจสอบว่าโดนโจมตีไปแล้วหรือยัง

ถึงจะอัปเดตแล้วก็ตาม สิ่งที่ต้องทำเพิ่มคือการ Monitor ว่ามีร่องรอยของการโจมตีเกิดขึ้นหรือเปล่า เพราะถ้า Server ถูก Compromise(ถูกควบคุม) ไปก่อนแล้ว การอัปเดตก็ช่วยอะไรไม่ได้ Indicator ที่ควรเช็กมีดังนี้

  1. มี Child Process ที่แตกออกมาจาก Puma(Web Server ที่ GitLab ใช้) หรือเปล่า ถ้ามี อาจแปลว่าเกิด Remote Code Execution แล้วมีการสร้าง Process ใหม่ขึ้นมา
  2. มีไฟล์ที่ถูกสร้างในโฟลเดอร์ /tmp โดย User git หรือเปล่า ซึ่ง User git สำคัญมากเพราะเป็น User ที่ GitLab ใช้
  3. มี Crontab ที่ถูกสร้างโดย User git หรือมีการเปลี่ยน SSH Key เพื่อให้ Remote เข้ามาได้ในภายหลังหรือเปล่า
  4. มี Log ที่ผิดปกติหรือเปล่า เช่น Regular Expression Worker Crash บ่อย ๆ, การ Render ไฟล์ Org-mode เกิด Error หรือ Markdown อื่น ๆ อย่างไฟล์ README ที่อยู่ใน GitLab เกิด Error

ตัวอย่างคำสั่งที่ใช้ตรวจสอบ

# List Process แบบแสดงลำดับ Parent / Child
ps -ef --forest

# ไฟล์ใน /tmp ที่สร้างโดย User git
find /tmp -user git -type f -ls

# Crontab ของ User git
crontab -u git -l

# SSH Key ของ GitLab
ls -al /var/opt/gitlab/.ssh

Indicator เหล่านี้ไม่ได้หมายความว่าโดนโจมตีไปแล้วแน่นอน แต่เป็นข้อมูลที่บ่งชี้ว่า Server ของเรา อาจจะ ถูกโจมตีไปแล้ว

ตัวอย่างคำสั่งตรวจสอบ Process, ไฟล์ใน /tmp, Crontab และ SSH Key บน GitLab Server

วิธีรับมือและการ Patch

สิ่งแรกคือการอัปเดต โดยเฉพาะ GitLab เวอร์ชันเก่าต้องแก้ไขให้เร็วที่สุด

ขั้นตอนการรับมือ

  1. ระบุ GitLab เวอร์ชันที่ใช้อยู่
  2. Review Patch ที่ต้องใช้ตามเวอร์ชันในหัวข้อก่อนหน้า
  3. วางแผนการ Backup และ Restore
  4. อัปเดต แล้วย้าย Database ขึ้นมาอยู่ในเวอร์ชันใหม่
  5. ตรวจว่าเวอร์ชันที่ใช้อยู่ตอนนี้เป็นเวอร์ชันล่าสุดแล้วหรือยัง
  6. ตรวจหาความผิดปกติต่าง ๆ ตาม Indicator ในหัวข้อก่อนหน้า
  7. Rotate Secret ทั้งหมด ไม่ว่าจะเป็น API Token ที่ใช้กับ GitLab Runner, SSH Key ที่ใช้ระหว่างเครื่อง Developer กับ GitLab หรือ Credential ที่ใช้เชื่อมกับ Third Party และเครื่องมืออื่น ๆ ที่ GitLab เชื่อมต่ออยู่

ขั้นตอนการรับมือ 7 ข้อ ตั้งแต่ระบุเวอร์ชันจนถึง Rotate Secret

สรุป

CVE-2026-110264 เป็นช่องโหว่ที่มีความรุนแรงสูงที่สุด คือ CVSS 10 เต็ม 10 และส่งผลกระทบเป็นวงกว้าง สิ่งที่ควรทำมี 3 ข้อ

  1. อัปเดต GitLab เป็นเวอร์ชันที่มี Patch
  2. Monitor ความผิดปกติ เพราะเราไม่แน่ใจว่าเครื่องถูก Compromise ไปแล้วหรือยัง
  3. Rotate Secret ทั้งหมด เพื่อให้แน่ใจว่า Secret ที่อาจหลุดออกไปจะไม่สามารถนำกลับมาใช้ได้อีก

สรุป CVE-2026-110264 อัปเดต GitLab, Monitor และ Rotate Secret

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

Phanupong Permpimol
Follow me