วันที่ข่าวช่องโหว่ใหญ่ของ library ยอดนิยมออกมา คำถามแรกที่ทีมได้รับเสมอคือ "เราใช้ตัวนี้ที่ไหนบ้าง" ถ้าบริษัทมี Git server ที่สะสม repo มาหลายปี คำตอบมักกระจายอยู่ในหลายร้อย project ที่แต่ละทีมดูแลเอง บาง project มี SCA job ใน pipeline แต่ส่วนใหญ่ไม่มี
บทความนี้สรุปวิธีที่เราใช้ไล่หาแพ็กเกจและ container image ที่ได้รับผลจาก CVE ข้ามทุก repo ด้วยสคริปต์ที่อ่านอย่างเดียว ไม่ clone ทั้ง repo ไม่ใช้ runner ไม่แก้ .gitlab-ci.yml ของใคร และไม่เขียนอะไรกลับไปที่ Git server เลย ตัวอย่างใช้ GitLab แต่แนวคิดเดียวกันใช้กับ Gitea หรือ GitHub ได้ ชื่อโดเมน project และตัวเลขในบทความเป็นค่าตัวอย่างทั้งหมด
ทำไมต้องอ่านอย่างเดียว
ทางที่ "ถูกตำรา" คือให้ทุก project เพิ่ม dependency scanning ใน CI แต่ในทางปฏิบัติ project เก่าจำนวนมากไม่มีคนดูแลประจำ pipeline บางตัวพังอยู่แล้ว และการเข้าไปแก้ CI ของหลายร้อย repo ต้องขอสิทธิ์และขอความเห็นจากหลายทีม สิ่งที่เราต้องการในวันแรกคือภาพรวมที่ตอบได้ทันที ไม่ใช่ระบบที่สมบูรณ์
การจำกัดตัวเองให้อ่านอย่างเดียวช่วยได้สามเรื่อง ขอสิทธิ์ได้เร็ว เพราะ token ไม่มีสิทธิ์เขียน ถ้าสคริปต์มีบั๊ก ผลเสียคือรายงานไม่ครบ ไม่ใช่ repo ของใครเสีย และเจ้าของ project ยังเป็นคนตัดสินใจว่าจะอัปเกรดเมื่อไร ไม่ใช่ bot ที่เปิด issue ใส่ทุกคนพร้อมกัน
ขั้นที่ 1: เลือก project ที่ต้องสแกนจริง
สร้าง token แยกสำหรับงานนี้โดยเฉพาะ ให้ scope แค่ read_api และ read_repository อย่าใช้ token ของบัญชี admin แม้จะสะดวกกว่า เพราะ token นี้จะไปอยู่ใน cron และสคริปต์อีกนาน เก็บ token ไว้ในไฟล์ที่มีสิทธิ์ 600 ในรูปแบบ header แล้วให้ curl อ่านจากไฟล์ จะได้ไม่โผล่ใน ps, shell history หรือ log
# ~/.config/gitlab-readonly.header (chmod 600)
# PRIVATE-TOKEN: <token>
API="https://git.example.com/api/v4"
H="@$HOME/.config/gitlab-readonly.header"
page=1
while :; do
out=$(curl -sS -H "$H" \
"$API/projects?archived=false&per_page=100&page=$page&order_by=last_activity_at")
[ "$(echo "$out" | jq length)" -eq 0 ] && break
echo "$out" | jq -r '.[] | [.id, .path_with_namespace, .default_branch,
.last_activity_at, .empty_repo] | @tsv'
page=$((page+1))
done > projects.tsv
ตอนลองครั้งแรก เราพบว่าเกือบครึ่งของ project ถูก archive ไปแล้ว และอีกจำนวนมากไม่มีใครแตะเกินปี ถ้าสแกนทุกตัวเท่ากัน รายงานจะเต็มไปด้วยผลจาก repo ที่ไม่มีใคร deploy แล้ว เราจึงตั้งขอบเขตว่าสแกนเฉพาะ project ที่ไม่ archive และมี last_activity_at ภายใน 90 วัน ข้าม empty_repo และคำนวณขอบเขตใหม่ทุกรอบ project ที่กลับมามีความเคลื่อนไหวจะถูกเพิ่มเองอัตโนมัติ ในกรณีของเรา วิธีนี้ทำให้งานเหลือประมาณหนึ่งในสามของทั้งหมด
อีกเรื่องที่ควรตัดสินใจตั้งแต่แรกคือ branch ถ้าสแกนแค่ default_branch อาจพลาดโค้ดที่รันจริง เพราะบางทีม deploy จาก branch production หรือ release/* ให้สแกน default branch บวก branch ตาม pattern ที่ตกลงกัน และข้าม pattern ที่ไม่มีใน project นั้น
ขั้นที่ 2: ดึงเฉพาะไฟล์ที่ต้องใช้ ไม่ clone ทั้ง repo
การ clone หลายร้อย repo กินทั้งเวลา ดิสก์ และ bandwidth ของ Git server ทั้งที่เราต้องการแค่ไม่กี่ไฟล์ ให้ใช้ tree API แบบ recursive หา path ที่สนใจ แล้วดึงเฉพาะไฟล์นั้นผ่าน raw file API
import os, re, requests, urllib.parse
API = "https://git.example.com/api/v4"
# ใช้ไฟล์ header เดียวกับ curl: "PRIVATE-TOKEN: <token>"
name, _, value = open(os.path.expanduser("~/.config/gitlab-readonly.header")).read().partition(":")
HDR = {name.strip(): value.strip()}
WANT = re.compile(r"(^|/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|composer\.lock"
r"|go\.sum|uv\.lock|poetry\.lock|requirements[^/]*\.txt"
r"|Dockerfile[^/]*|docker-compose[^/]*\.ya?ml|compose\.ya?ml)$")
SKIP = re.compile(r"(^|/)(vendor|node_modules|third_party)/")
def wanted_paths(pid, ref):
page = 1
while True:
r = requests.get(f"{API}/projects/{pid}/repository/tree", headers=HDR, timeout=60,
params={"ref": ref, "recursive": "true", "per_page": 100, "page": page})
r.raise_for_status()
for item in r.json():
p = item["path"]
if item["type"] == "blob" and WANT.search(p) and not SKIP.search(p):
yield p
if not r.headers.get("X-Next-Page"):
break
page = int(r.headers["X-Next-Page"])
def fetch(pid, ref, path):
enc = urllib.parse.quote(path, safe="")
r = requests.get(f"{API}/projects/{pid}/repository/files/{enc}/raw",
headers=HDR, params={"ref": ref}, timeout=60)
r.raise_for_status()
return r.content
บทเรียนจากขั้นนี้มีสามข้อ
- lockfile สำคัญกว่า manifest
package.jsonหรือcomposer.jsonบอกแค่ช่วงเวอร์ชันอย่าง^2.1ถ้าเอาไปเทียบกับฐานข้อมูลช่องโหว่ จะได้ทั้งผลเกินจริงและผลที่หลุด ให้ใช้ lockfile ก่อน และใช้ manifest เมื่อไม่มี lockfile เท่านั้น โดยติดป้ายในรายงานว่า "เวอร์ชันไม่แน่นอน" - ข้ามโฟลเดอร์ที่ commit dependency ไว้ทั้งก้อน project PHP รุ่นเก่าบางตัว commit
vendor/ไว้ใน repo ซึ่งมีcomposer.lockของ library ย่อยอยู่ข้างใน ผลคือแพ็กเกจเดียวกันถูกนับหลายรอบ และบางตัวไม่ได้ถูกใช้จริงด้วย - เก็บไฟล์ไว้ตาม path เดิม ให้วางไฟล์ที่ดึงมาในโครงสร้างโฟลเดอร์เดียวกับใน repo เพราะ monorepo มักมีหลาย lockfile และรายงานต้องบอกได้ว่าเจอใน path ไหน
ถ้า repo ใหญ่จน tree API ช้า ทางเลือกคือ git clone --depth 1 --filter=blob:none --sparse แล้ว sparse-checkout เฉพาะไฟล์ที่ต้องการ แต่สำหรับงานส่วนใหญ่ API ก็พอ และไม่ต้องเก็บ repo ไว้ในเครื่องสแกนเลย
ขั้นที่ 3: รวบรวม container image ที่ใช้จริง
ช่องโหว่ไม่ได้อยู่แค่ใน library ของแอป base image ที่ล้าสมัยก็เป็นต้นเหตุบ่อยพอกัน จากไฟล์ที่ดึงมาในขั้นที่ 2 ให้แยกชื่อ image ออกจาก FROM ใน Dockerfile, image: ใน compose และ manifest ของ Kubernetes
grep -rhoE '^\s*FROM\s+[^ ]+' files/ | awk '{print $2}' \
| grep -v '^\$' | sort | uniq -c | sort -rn > images.txt
grep -rhoE '^\s*image:\s*[^ ]+' files/ | awk '{print $2}' | tr -d '"' \
| sort | uniq -c | sort -rn >> images.txt
สิ่งที่เจอบ่อยและควรแยกเป็นหมวดในรายงาน
- tag ที่ไม่บอกเวอร์ชัน เช่น
:latestหรือไม่ใส่ tag เลย สแกนจากไฟล์ไม่ได้ว่าใช้เวอร์ชันไหน ให้รายงานเป็น "ไม่ได้ pin" แยกไว้ แทนที่จะเดา FROMที่ใช้ตัวแปร เช่นFROM node:${NODE_VERSION}ให้แทนค่าจากARGที่มีค่า default ในไฟล์เดียวกัน ถ้าไม่มีค่า default ก็ติดป้ายว่าไม่ทราบเวอร์ชัน- multi-stage build stage สุดท้ายคือสิ่งที่ไปรันจริง ส่วน stage builder มีผลต่อ supply chain ให้แยกสองกลุ่มนี้ เพราะความเร่งด่วนต่างกัน
หลัง dedup แล้ว จำนวน image ที่ไม่ซ้ำกันมักน้อยกว่าจำนวน repo มาก เพราะหลาย project ใช้ base image ชุดเดียวกัน จึงสแกนด้วย trivy image ทีละ image บนเครื่องที่แยกจาก production ได้โดยไม่ต้อง build อะไรเลย
ขั้นที่ 4: สแกนด้วยสองเครื่องมือแล้วรวมผล
เราใช้ osv-scanner และ Trivy คู่กัน เพราะแต่ละตัวรองรับ lockfile ไม่เหมือนกัน ในรุ่นที่เราใช้ตอนนั้น lockfile ของ Python บางรูปแบบอ่านได้จากตัวเดียว ส่วนอีกตัวให้ข้อมูลเวอร์ชันที่แก้แล้วละเอียดกว่า ก่อนเลือกใช้ให้เช็กรายการ lockfile ที่แต่ละเครื่องมือรองรับในเวอร์ชันปัจจุบัน
osv-scanner --recursive --format json files/$P > scan/$P.osv.json
trivy fs -q --scanners vuln --format json -o scan/$P.trivy.json files/$P
ปัญหาที่ตามมาคือผลซ้ำ ช่องโหว่ตัวเดียวกันมักมีทั้งรหัส GHSA และ CVE ถ้านับตรง ๆ ตัวเลขจะพองเกือบเท่าตัว ให้รวม alias ทั้งหมดของแต่ละรายการก่อน แล้วใช้คีย์ (ecosystem, ชื่อแพ็กเกจ, CVE) ต่อ project ถ้ารายการไหนไม่มี CVE ค่อยใช้ GHSA แทน แต่ละแถวควรเก็บเวอร์ชันที่พบ path ของ lockfile และเวอร์ชันที่แก้แล้ว (ถ้ามี) เพื่อให้เจ้าของ project ลงมือได้เลยโดยไม่ต้องสแกนซ้ำ
ขั้นที่ 5: จัดลำดับให้คนอ่านไหว
รอบแรกที่เราได้ผลรวม ตัวเลขมีเป็นพันแถว ถ้าส่งไปทั้งก้อนจะไม่มีใครอ่าน เราจึงเรียงตามความเสี่ยงจริงแทนการเรียงตามคะแนน CVSS อย่างเดียว
- อยู่ใน CISA KEV คือมีการโจมตีจริงแล้ว ให้ขึ้นบนสุดเสมอ ไม่ว่าคะแนนจะเท่าไร
- Critical / High ที่อยู่ใน dependency ของ runtime ไม่ใช่ devDependencies หรือเครื่องมือทดสอบ
- มีเวอร์ชันที่แก้แล้ว แปลว่าแก้ได้ทันที ต่างจากรายการที่ต้องรอ upstream
รายงานหนึ่งไฟล์ต่อ project เป็น CSV หรือ Markdown ก็พอ แล้วกำหนดเวลาตอบสนองตามระดับ เช่น Critical ภายใน 7 วัน High ภายใน 30 วัน Medium ภายใน 90 วัน ตัวเลขเหล่านี้ควรตกลงกับทีมก่อนส่งรายงานฉบับแรก ไม่ใช่หลังจากนั้น
ขั้นที่ 6: สแกนซ้ำหลังแก้ แล้วเทียบผล
เมื่อทีมอัปเกรดแล้ว อย่าดูแค่ว่าจำนวนลดลงหรือไม่ ให้สแกนซ้ำด้วยคำสั่งเดิม แล้วเทียบผลก่อนกับหลังแก้ด้วยคีย์เดียวกัน แยกเป็นสามกลุ่ม
- fixed มีในผลก่อนแก้ แต่ไม่มีในผลหลังแก้
- remain ยังอยู่ทั้งสองครั้ง มักเกิดจาก dependency ทางอ้อมที่ล็อกเวอร์ชันไว้
- new เพิ่งโผล่หลังแก้ เกิดได้จริงเพราะการอัปเกรดตัวหนึ่งดึง dependency ทางอ้อมชุดใหม่เข้ามา
กลุ่ม new เป็นสิ่งที่เราไม่คาดว่าจะเจอบ่อยขนาดนี้ ถ้าไม่เทียบแบบนี้ ทีมจะเห็นแค่ตัวเลขรวมที่ลดลงไม่มาก แล้วสรุปผิดว่าการอัปเกรดไม่ได้ผล
กับดักที่เจอ
- ใช้ token ของ admin เพราะสะดวก แล้ว token ไปค้างอยู่ใน cron ที่มีสิทธิ์เกินงาน
- ใส่ token ใน URL หรือ argv จนไปโผล่ใน log ของ proxy หรือ shell history
- สแกน manifest แทน lockfile แล้วได้ผลที่ทั้งเกินและขาด
- ไม่ข้าม
vendor/ที่ commit ไว้ จนแพ็กเกจเดียวกันถูกนับหลายสิบครั้ง - นับ GHSA และ CVE ของช่องโหว่เดียวกันเป็นสองรายการ
- ลืมจัดการ pagination ของ API ทำให้เห็นแค่ 20 project แรกโดยไม่รู้ตัว
- ยิง API พร้อมกันหลายสิบ request จน Git server ช้า ควรจำกัด concurrency และรันนอกเวลาทำงาน
- ให้สคริปต์เปิด issue อัตโนมัติตั้งแต่รอบแรก ก่อนจะรู้ว่าผลมี noise มากแค่ไหน
ถ้าอยากให้ LLM ช่วยคัดกรองผลรอบดึกโดยยังไม่ให้ลงมือแก้เอง ดูแนวทางได้ใน ให้ LLM ที่ host เองทำงานกะดึกแบบ shadow mode
สรุป
การตอบคำถาม "เราใช้ library ตัวนี้ที่ไหนบ้าง" ไม่จำเป็นต้องรอให้ทุก project มี SCA ใน pipeline ใช้ token แบบอ่านอย่างเดียว เลือกเฉพาะ project ที่ยังมีชีวิต ดึงเฉพาะ lockfile และไฟล์ที่บอก image สแกนด้วยสองเครื่องมือแล้วรวมผลให้ไม่ซ้ำ จัดลำดับด้วย KEV ก่อนคะแนน แล้ววัดผลด้วยการเทียบก่อนกับหลังแก้
เมื่อ inventory นี้รันเป็นรอบได้แล้ว ครั้งหน้าที่มีข่าวช่องโหว่ใหญ่ คำตอบจะออกมาในไม่กี่นาที และขั้นต่อไปอย่างการเพิ่ม SCA ใน CI ก็เริ่มได้จาก project ที่รายงานบอกว่าเสี่ยงที่สุดก่อน
