เมื่อเช้าไล่ดู artifact ของ pipeline ตัวหนึ่ง เจอไฟล์ sbom.spdx.json นอนอยู่ครบทุก build ย้อนหลังไปเป็นร้อยตัว ขนาดรวมก็ไม่ใช่น้อย ถามในทีมว่า "ใครเคยเปิดไฟล์นี้บ้าง" เงียบกริบ 555

นี่แหละอาการคลาสสิก SBOM ถูกสร้างเพราะ checklist บอกให้สร้าง (หรือเพราะ audit ถาม) แล้วก็ upload เก็บไว้เฉยๆ เหมือนใบเสร็จที่ยัดลิ้นชัก มีไว้อุ่นใจว่า "เรามีนะ" แต่วันที่ CVE ตัวใหม่โผล่มาแล้วหัวหน้าถามว่า "เรามี library ตัวนี้อยู่ใน service ไหนบ้าง" ทุกคนก็ยังต้องไปไล่ grep repo กันใหม่ทีละตัวอยู่ดี

บทความนี้จะเล่าวิธีที่ใช้อยู่จริงเพื่อให้ SBOM มี "งานทำ" ทุกวัน แทนที่จะเป็นแค่ไฟล์ประดับ pipeline

ปัญหาจริงไม่ใช่ "ไม่มี SBOM" แต่คือ "scan แค่ตอน build"

pipeline ส่วนใหญ่ (รวมถึงที่เคยเขียนไว้ในบทความ layered scanning ก่อนหน้า) scan image ตอน build แล้วจบ ถ้าวันนั้นผ่าน gate ก็ถือว่าสะอาด

ปัญหาคือ image ที่ build เมื่อ 3 เดือนก่อนแล้วยังรันอยู่ใน production วันนี้ มันไม่ได้ถูก scan ใหม่เลยตั้งแต่วันนั้น ระหว่างนั้นมี CVE ใหม่ประกาศออกมาเรื่อยๆ ทุกสัปดาห์ ตัว image ไม่ได้เปลี่ยน แต่ "ความรู้ของโลกเกี่ยวกับ image นั้น" เปลี่ยนไปแล้ว

ทางออกแบบดิบๆ คือ scan image ทุกตัวที่รันอยู่ใหม่ทุกวัน ซึ่งทำได้ แต่ต้อง pull image ทุกตัวมาแตก layer ใหม่ กิน bandwidth กิน registry rate limit และช้า พอ image เยอะขึ้นก็เริ่มมีคนแอบปิด cron ทิ้ง

SBOM คือทางลัดตรงนี้ เพราะมันคือรายการ package + version ที่ "แตก layer มาให้แล้ว" ตอน build เราเอารายการนี้ไปเทียบกับ vulnerability database ใหม่ได้ทุกวันโดยไม่ต้องแตะตัว image เลย เร็วกว่ากันเยอะ

โครงที่ใช้: สร้างครั้งเดียว, เซ็นติด image, scan ซ้ำได้ตลอด

แนวคิดมีแค่ 3 ท่อน

  1. ตอน build: สร้าง SBOM จาก image ที่เพิ่ง build (ไม่ใช่จาก source อย่างเดียว เพราะ base image ก็มี package ของมันเอง)
  2. ตอน push: เซ็น SBOM เป็น attestation แนบไปกับ digest ของ image ใน registry เลย ไม่ใช่โยนเป็นไฟล์แยกไว้ใน artifact store
  3. ทุกวัน: job ตัวหนึ่งดึงรายการ image digest ที่รันอยู่ใน cluster จริง, ดึง SBOM ที่เซ็นแล้วของแต่ละตัว, verify ลายเซ็น แล้วค่อย scan

ข้อ 2 สำคัญกว่าที่คิด ถ้า SBOM อยู่แยกจาก image เดี๋ยวสักวันจะมีคนถามว่า "ไฟล์นี้เป็นของ build ไหน" แล้วไม่มีใครตอบได้ การผูกกับ digest ตัดปัญหานี้ทิ้ง และการเซ็นทำให้มั่นใจว่า SBOM ไม่ได้ถูกแก้ทีหลัง (ไม่งั้นใครก็ลบบรรทัด log4j ออกจาก JSON แล้ว scan ผ่านได้)

ท่อนที่ 1 และ 2: ใน pipeline

ตัวอย่างนี้ใช้ Syft สร้าง SBOM และ cosign แบบ keyless (OIDC ของ CI) แนบ attestation ใครใช้ Trivy อยู่แล้วก็ใช้ trivy image --format spdx-json แทน Syft ได้ ผลลัพธ์ใกล้เคียงกัน

# สมมติตัวแปรพวกนี้มาจาก step build ก่อนหน้า (ชื่อสมมติทั้งหมด) IMAGE="registry.example.com/team/payment-api" DIGEST="$(crane digest "${IMAGE}:${GIT_SHA}")" REF="${IMAGE}@${DIGEST}" # 1) สร้าง SBOM จาก image จริง อ้างด้วย digest เสมอ ไม่ใช่ tag syft scan "${REF}" -o spdx-json=sbom.spdx.json # 2) เซ็นเป็น attestation ผูกกับ digest (keyless ใช้ OIDC token ของ CI) cosign attest --yes \ --predicate sbom.spdx.json \ --type spdxjson \ "${REF}" 

จุดที่คนพลาดบ่อย:

ใช้ tag แทน digest ตอนสร้างหรือเซ็น ผลคือ tag latest ถูก push ทับไปแล้ว SBOM ชี้ไปของคนละตัว อ้างด้วย @sha256:... ทุกครั้ง จบ

สร้าง SBOM จาก source directory อย่างเดียว ได้แต่ dependency ของ app แต่ไม่เห็น openssl, glibc, หรือ package ใน base image เลย ซึ่งครึ่งหนึ่งของ CVE ที่โผล่มาจริงมักอยู่ตรงนั้น ถ้าอยากได้ทั้งคู่ก็ทำสองอัน แต่อันที่ผูกกับ image ต้องมาจาก image

ลืมว่า keyless ต้องให้สิทธิ์ CI ขอ OIDC token (บน GitHub Actions คือ permissions: id-token: write) ไม่งั้น step นี้จะพังแบบ error งงๆ ตอนตีหนึ่งของวันที่รีบ release

ท่อนที่ 3: re-scan รายวันจากของที่รันอยู่จริง

ตรงนี้คือหัวใจ ถ้าไม่มีท่อนนี้ ท่อน 1 กับ 2 ก็เป็นแค่การเก็บใบเสร็จที่มีลายเซ็นสวยขึ้นเท่านั้นเอง

#!/usr/bin/env bash set -euo pipefail # ดึง image digest ที่รันอยู่จริงใน cluster (unique) kubectl get pods -A -o jsonpath='{range .items[*]}{range .status.containerStatuses[*]}{.imageID}{"\n"}{end}{end}' \ | sed 's#^docker-pullable://##' \ | sort -u > running-images.txt grype db update while read -r REF; do # verify ลายเซ็นก่อนเชื่อ SBOM (ระบุ identity ของ pipeline ที่อนุญาตเท่านั้น) if ! cosign verify-attestation \ --type spdxjson \ --certificate-identity-regexp '^https://github.com/your-org/.+/.github/workflows/release.yml@refs/heads/main$' \ --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \ "${REF}" 2>/dev/null \ | jq -r '.payload | @base64d | fromjson | .predicate' > sbom.json; then echo "NO_VALID_SBOM ${REF}" continue fi grype sbom:./sbom.json --only-fixed --fail-on high -o json > "result-$(echo "${REF}" | sha256sum | cut -c1-12).json" \ || echo "HIGH_FOUND ${REF}" done < running-images.txt 

ข้อสังเกตจากการรันจริง:

NO_VALID_SBOM มีค่าพอๆ กับ HIGH_FOUND เพราะมันบอกว่ามี image ที่ไม่ได้มาจาก pipeline หลัก (ใครสักคน kubectl set image มือ หรือ chart ของ third-party ที่ไม่มี SBOM) รอบแรกที่เปิด job นี้เจอเยอะจนตกใจ ถือว่าได้ inventory ฟรีไปอีกหนึ่งอย่าง

--only-fixed ช่วยลด noise มหาศาล CVE ที่ยังไม่มี fix เราทำอะไรได้น้อย แยกไปดูเป็นรายสัปดาห์พอ อย่าเอามาปลุกคน

grype db update แยกออกมาก่อน loop เพื่อให้ทุก image ถูกเทียบกับ DB เวอร์ชันเดียวกัน ไม่งั้นผลแต่ละตัวจะเทียบไม่ได้ และอย่าลืม cache DB ไว้ใน runner ถ้ารันบ่อย

regex ของ --certificate-identity-regexp ต้องแคบ อย่าใส่ .* เพื่อให้ผ่านง่ายๆ เพราะนั่นเท่ากับเชื่อ SBOM ที่ใครก็ได้ใน Sigstore เซ็นมา ลายเซ็นจะไม่มีความหมายอะไรเลย

เอาผลไปทำอะไรต่อ (ส่วนที่มักถูกข้าม)

scan ได้ผลแล้วแต่ส่งเข้า Slack channel ที่มี 400 ข้อความ unread อยู่แล้ว ก็เหมือนไม่ได้ scan

สิ่งที่ได้ผลกว่า:

ผูกผลกับ owner ของ workload ผ่าน label บน Deployment (เช่น team) แล้วเปิด ticket ให้ทีมนั้นตรงๆ ไม่ใช่โยนเข้าห้องรวม

ตั้ง SLA ตามความรุนแรงที่ทีมตกลงกันเอง เช่น critical ที่มี fix ต้องจบในกี่วัน แล้ววัดเป็นตัวเลข "อายุของ finding" แทนจำนวน finding เพราะจำนวนขึ้นลงตาม CVE ที่ประกาศ แต่อายุบอกว่าเราตามทันหรือเปล่า

เก็บผล JSON ทุกวันไว้ด้วย วันที่มีข่าว CVE ใหญ่ คำถาม "เรามีตัวนี้ไหม อยู่ตรงไหน" จะตอบได้ในไม่กี่นาทีจาก SBOM ที่มีอยู่แล้ว แทนที่จะเปิด war room ไล่ grep ทั้งบ่าย อันนี้แหละคือช่วงเวลาที่ SBOM คุ้มที่สุด

SBOM ไม่ใช่ยาวิเศษ

พูดให้ครบ SBOM มีข้อจำกัดของมัน

มันดีแค่เท่ากับ tool ที่สร้าง binary ที่ copy เข้าไปเฉยๆ (เช่น curl โหลดไฟล์ไบนารีมาวางใน Dockerfile) บาง tool จับไม่ได้หรือจับได้ไม่ครบ ถ้า Dockerfile ทีมไหนทำแบบนี้บ่อย SBOM จะสะอาดเกินจริง

มันบอกว่า "มี package นี้" แต่ไม่ได้บอกว่า "code path ที่มีช่องโหว่ถูกเรียกจริงไหม" ส่วนนี้ต้องคุยต่อด้วย VEX หรือการวิเคราะห์ reachability ซึ่งเป็นอีกเรื่องยาว

และมันไม่ได้แทนการ scan ตอน build gate ตอน build ยังต้องมีอยู่ ส่วน re-scan รายวันคือการเฝ้าของที่ผ่าน gate ไปแล้ว คนละหน้าที่กัน

Checklist สั้นๆ ก่อนไปเปิด job

  1. สร้าง SBOM จาก image digest ไม่ใช่ tag และไม่ใช่จาก source อย่างเดียว
  2. เซ็นเป็น attestation ผูก digest ใน registry ด้วย cosign
  3. job รายวันดึง digest จากของที่ "รันอยู่จริง" ไม่ใช่จากรายการ build
  4. verify ลายเซ็นด้วย identity ที่แคบ ก่อนเชื่อเนื้อหา SBOM
  5. update vulnerability DB ครั้งเดียวต่อรอบ แล้ว scan ทุก SBOM กับ DB เดียวกัน
  6. แยก NO_VALID_SBOM ออกมาเป็น finding ของตัวเอง
  7. ส่งผลถึง owner ตรงๆ และวัดอายุของ finding ไม่ใช่แค่จำนวน

Checklist SBOM re-scan รายวัน

ลองเปิดดู artifact store ของ pipeline ตัวเองดูก็ได้ ถ้าเจอ SBOM กองเป็นภูเขาแต่ไม่มี job ไหนอ่านมันเลย สัปดาห์นี้แหละเวลาที่ดีที่จะให้มันเริ่มทำงานจริงสักที

หมายเหตุ: ชื่อ registry, org, service และ workflow ในตัวอย่างเป็นชื่อสมมติทั้งหมด คำสั่งอ้างอิงตาม Syft, Grype และ cosign เวอร์ชันปัจจุบัน flag อาจต่างไปตามเวอร์ชันที่ใช้ เช็ค --help ก่อนเอาไปใส่ pipeline จริง