งานคัดกรองอัตโนมัติแทบทุกตัวมี pre-filter อยู่ด้านหน้า เพราะเราไม่อยากส่งทุกอย่างให้คนหรือ LLM อ่าน ระบบ triage CVE ก็เหมือนกัน ฟีดสาธารณะอย่าง NVD ออก CVE ใหม่และแก้ไขของเก่าวันละหลายร้อยรายการ ถ้าไม่กรองด้วยกฎง่าย ๆ ก่อน เช่น คะแนนความรุนแรงและรายชื่อผลิตภัณฑ์ที่เราใช้ ต้นทุนจะบานทันที

ปัญหาคือ pre-filter ที่ทำงานดีจะทิ้งของได้อย่างเงียบที่สุด รายการที่ถูกทิ้งไม่โผล่ในรายงาน ไม่มีใครเห็น และไม่มีใครรู้ว่าพลาด จนวันที่ทีมกลางวันเจอข่าวสำคัญที่กะกลางคืนข้ามไป บทความนี้สรุปสิ่งที่เราเพิ่มให้ระบบ triage CVE กะดึกแบบ shadow mode หลังสัปดาห์แรก ได้แก่ rescue path สำหรับรายการที่เกือบผ่าน cap ต่อรอบที่ carry-over ได้จริง และ drift check ของไฟล์ config รวมถึงบทเรียนจากคืนแรกที่ใช้งาน ซึ่งเจอช่องโหว่ในการออกแบบของเราเองตั้งแต่ยังไม่ทันข้ามคืน

แผนภาพ pre-filter ที่ไม่ทิ้งเงียบ ฟีด CVE เข้าสู่ pre-filter แบบโค้ด ผลแยกเป็นสามทาง คือผ่านเข้าคิวหลัก รายการที่เกือบผ่านเข้าสู่ rescue tiers หกชั้น และรายการที่ไม่มีสัญญาณถูกนับใน drop_counts ส่วน rescue มี cap ต่อรอบ รายการที่เกินถูกเก็บใน state เพื่อกลับมาในรอบถัดไป ทั้งสองคิวผ่าน LLM และ verifier ที่เป็นโค้ดก่อนออกรายงานเช้า ด้านบนเป็น drift check ที่เทียบ config ที่ deploy กับ repo
ภาพรวม: ทุกการทิ้งต้องมีเหตุผล รายการที่เกือบผ่านได้ดูซ้ำ ส่วนที่เกินโควตาถูกยกไปรอบหน้า และ config ถูกตรวจ drift ทุกรอบ (คลิกที่ภาพเพื่อดูขนาดเต็ม)

ทำไม pre-filter ถึงพลาดแบบเงียบ

pre-filter ของเรามีด่านเรียงกันสี่ด่าน คือ (1) ด่านความรุนแรง ต้องมี CVSS ตั้งแต่ 7.0 ขึ้นไป หรืออยู่ใน KEV หรือ scanner ภายในเจอ (2) ด่าน watchlist ใช้ regex กับคำอธิบาย หรือจับคู่ CPE vendor:product (3) ตัดผู้ขายหรือบริการที่อยู่นอกขอบเขต และ (4) ปลั๊กอินของ CMS ต้องอยู่ในรายการที่ติดตั้งจริง ทุกด่านมีเหตุผลที่ดี แต่ก็มีจุดบอดของมันเอง

  • watchlist ตามไม่ทันของจริง พอมีผลิตภัณฑ์ใหม่เข้ามาใช้หรือมีชื่อเรียกใหม่ regex เดิมก็จับไม่ได้
  • คะแนนมาช้า CVE ใหม่จำนวนมากยังไม่มี CVSS จาก NVD แต่ CNA ของผู้ผลิตระบุความรุนแรงไว้แล้ว
  • กฎตัดนอกขอบเขตกว้างเกินไป กฎที่ตั้งใจตัดบริการคลาวด์บางตัวอาจตัด CVE ที่เกี่ยวกับเราติดไปด้วย
  • ชื่อไม่ตรงกัน ชื่อปลั๊กอินใน CVE กับชื่อในรายการติดตั้งสะกดต่างกันนิดเดียว ก็ถูกตัดสินว่า "ไม่ได้ติดตั้ง" แล้ว

ทุกกรณีมีจุดร่วมเดียวกัน คือมีสัญญาณบางอย่างว่าอาจเกี่ยวกับเรา แต่ไม่ถึงเกณฑ์ นี่แหละคือกลุ่มที่ควรได้ดูซ้ำ ส่วนรายการที่ไม่มีสัญญาณอะไรเลยก็ทิ้งได้ แต่ต้องนับเก็บไว้

ขั้นที่ 1: ให้ทุกการทิ้งมีเหตุผลและถูกนับ

ก่อนทำอะไรต่อ ให้แก้ฟังก์ชัน pre-filter ให้คืนค่าเหตุผลทุกครั้งที่ทิ้ง แทนการคืนแค่ True/False แล้วนับรวมไว้ในรายงานของแต่ละรอบ แค่นี้ก็เห็นแล้วว่าด่านไหนทิ้งเยอะผิดปกติ

def prefilter(cve, watch):
    if not severe_enough(cve):
        return False, "below_threshold"
    hits = watch.match(cve)
    if not hits:
        return False, "no_watch_hit"
    if out_of_scope(cve):
        return False, "out_of_scope"
    if is_plugin(cve) and not plugin_installed(cve):
        return False, "plugin_not_installed"
    return True, None

drop_counts = Counter()
for cve in window:
    ok, reason = prefilter(cve, watch)
    if not ok:
        drop_counts[reason] += 1

ตัวเลข drop_counts ควรขึ้นหัวรายงานทุกเช้า ถ้าวันหนึ่ง out_of_scope พุ่งขึ้นสิบเท่า แปลว่ากฎตัดนอกขอบเขตเริ่มกินของที่ไม่ควรกินแล้ว

ขั้นที่ 2: แบ่งรายการที่เกือบผ่านเป็นชั้น (rescue tiers)

rescue path คือการส่งรายการที่ pre-filter จะทิ้ง แต่มีสัญญาณบางอย่าง ไปให้ LLM ดูซ้ำอีกรอบ เราแบ่งสัญญาณเป็นชั้นตามความน่าเชื่อถือ ชั้นบนได้คิวก่อน

  1. watch_excluded ตรง watchlist แต่โดนกฎนอกขอบเขต และรุนแรงตั้งแต่ระดับ High
  2. plugin_near ระบบตัดสินว่าปลั๊กอินไม่ได้ติดตั้ง แต่ชื่อปลั๊กอินที่ติดตั้งอยู่ปรากฏในชื่อของมัน
  3. cna_vendor / cpe_vendor ไม่ตรง watchlist แต่โดเมนอีเมลของ CNA หรือ vendor ใน CPE เป็นผู้ผลิตที่เราติดตาม เช่น ทีม security ของภาษาโปรแกรมที่เราใช้
  4. name_mention คำอธิบายเอ่ยชื่อผลิตภัณฑ์ที่เราติดตาม
  5. umbrella_vendor เหมือนข้อ 3 แต่เป็นผู้ผลิตที่มีผลิตภัณฑ์หลายร้อยตัว จึงให้ความสำคัญต่ำกว่า
  6. watch_below_high ตรง watchlist แต่คะแนนอยู่ระดับ Medium (เราข้าม Linux kernel และจำกัดไม่เกิน 3 รายการต่อผลิตภัณฑ์ต่อรอบ ไม่อย่างนั้น kernel อย่างเดียวก็กินโควตาหมด)

สองเรื่องที่ช่วยได้มาก เรื่องแรกคือใช้หลายแหล่งตัดสินว่า "สนใจผู้ผลิตนี้" ทั้ง watchlist ที่ deploy อยู่ watchlist ใน repo และ inventory ที่ใช้ตรวจเวอร์ชัน ต่อให้ไฟล์บนเครื่องค้างอยู่รุ่นเก่า ก็ยังได้ดูซ้ำ เรื่องที่สองคือแนบ tier, สัญญาณ และเหตุผลที่ถูกทิ้งไปกับรายการ เพื่อให้คนอ่านรายงานรู้ว่ารายการนี้เข้ามาทางประตูหลัง และเห็นว่าชั้นไหนมีประโยชน์จริง

def rescue_tier(cve, reason, affinity):
    high = best_cvss(cve) >= 7.0 or cna_severity(cve) in {"high", "critical"}
    if reason == "out_of_scope" and high:
        return "watch_excluded"
    if reason == "plugin_not_installed" and high and near_installed_plugin(cve):
        return "plugin_near"
    if reason == "no_watch_hit" and (high or unscored(cve)):
        if affinity.cna_domain(cve) or affinity.cpe_vendor(cve):
            return "cna_vendor"
        if high and affinity.names_product(cve):
            return "name_mention"
        if affinity.umbrella_vendor(cve):
            return "umbrella_vendor"
    if reason == "below_threshold" and watch_hit(cve) and 4.0 <= best_cvss(cve) < 7.0:
        return "watch_below_high"
    return None  # ไม่มีสัญญาณ: นับใน drop_counts แต่ไม่ส่ง

ขั้นที่ 3: ตั้ง cap ต่อรอบ และทำ carry-over ให้ครบทุกทาง

rescue path เพิ่มงานให้ LLM เสมอ เราจึงตั้งกติกาไว้สามข้อ

  • rescue รันหลังคิวหลักเสร็จ และใช้งบเวลาก้อนเดียวกับคิวหลัก ถ้าคาดว่าจะทำต่อไม่ทันงบ ก็ไม่เริ่มรายการใหม่ ทำให้แต่ละรอบไม่นานขึ้นกว่าเดิม
  • มี cap ต่อรอบ เช่น ไม่เกิน 40 รายการ ถ้าเกินจะบันทึก log ว่า cap hit พร้อมรหัส CVE ที่ล้น
  • รายการที่เข้าคิวแล้วแต่ยังไม่ได้ตัดสิน จะถูกเก็บในไฟล์ state แล้วนำกลับมาในรอบถัดไป

ฟังดูครบ แต่คืนแรกที่ใช้งานจริงเราพบว่ายังทิ้งเงียบอยู่ cap ถูกชนสองครั้ง และมีรายการจำนวนหนึ่งที่ล้น cap ตั้งแต่ตอนจัดคิว มันจึงไม่เคยเข้าคิว ไม่ได้ถูกตัดสิน และไม่ได้ถูกเก็บลง state เพราะโค้ดเก็บเฉพาะ "รายการในคิวที่ยังไม่ได้ทำ" ผลคือรายการเหล่านี้หายไปเฉย ๆ ทั้งที่ชื่อ feature ของเราคือ "no silent drop"

วิธีแก้คือให้รายการที่ล้นทุกตัวไหลไปที่เดียวกับรายการที่ค้าง และให้ของค้างจากรอบก่อนได้คิวก่อนของใหม่

def build_rescue_queue(state, new_rescues, cap=40, pending_max=40):
    carried = state.get("rescue_pending", [])
    queue, overflow = [], []
    for item in dedupe(carried + sorted(new_rescues, key=tier_rank)):
        (queue if len(queue) < cap else overflow).append(item)
    return queue, overflow

queue, overflow = build_rescue_queue(state, rescues)
judged, unjudged = judge_within_budget(queue)
# ของที่ยังไม่ได้ตัดสิน + ของที่ล้น cap ต้องกลับไปที่ state ทั้งหมด
pending = (unjudged + overflow)[:PENDING_MAX]
dropped_for_real = (unjudged + overflow)[PENDING_MAX:]
state["rescue_pending"] = pending
report["rescue"] = {"judged": len(judged), "cap_hit": bool(overflow),
                    "carried": len(pending),
                    "dropped_ids": [c.id for c in dropped_for_real]}

สังเกตว่าแม้แต่ state ก็ยังมีเพดาน ถ้าเกินเพดานจริง ๆ ก็ต้องทิ้ง แต่ต้องทิ้งแบบมีรายชื่อในรายงาน ไม่ใช่หายไปเงียบ ๆ และให้เขียน test ยืนยันว่า "จำนวนที่ล้น = จำนวนที่ carry + จำนวนที่อยู่ใน dropped_ids" เสมอ

ขั้นที่ 4: ตรวจ drift ของ config ทุกรอบ

watchlist และ inventory ที่ระบบใช้จริงอยู่ใน path ของเครื่อง ส่วนต้นฉบับอยู่ใน Git เวลามีคนแก้ไฟล์บนเครื่องตรง ๆ ตอนรีบ หรือ deploy ไม่ครบ สองฝั่งก็จะไม่ตรงกันโดยไม่มีใครรู้ เราจึงเพิ่ม drift check ตอนเริ่มทุกรอบ โดยเทียบไฟล์ที่ deploy กับเนื้อหาใน repo ที่ commit ที่ deploy อยู่ (git show HEAD:config/watchlist.json) รวมถึงไฟล์ systemd unit และ logrotate และดูด้วยว่ามีการแก้ใน checkout ที่ยังไม่ commit หรือเปล่า

$ python3 drift.py --json
{"status": "drift",
 "files": [{"path": "watchlist.json", "added": ["product-x"], "removed": [],
            "changed_lines": 3}]}
$ echo $?
1   # 0 = ตรงกัน, 1 = drift, 2 = ตรวจไม่ได้

กติกาของ drift check มีสามข้อ คือ รายงานอย่างเดียว ไม่แก้เอง (เพราะไม่รู้ว่าฝั่งไหนถูก) สรุปแค่ชื่อ key และจำนวนบรรทัด ไม่พิมพ์เนื้อหาไฟล์ลงรายงาน และไม่แตะไฟล์ token หรือ secret เลย ถ้าตรวจไม่ได้ให้คืนสถานะ error ห้ามทำให้รอบนั้นล้ม

ขั้นที่ 5: เทียบกับสิ่งที่คนเจอ แล้วแก้ที่ต้นเหตุ

rescue path ช่วยได้เฉพาะรายการที่มีสัญญาณเท่านั้น ในคืนเดียวกันนั้นก็มีข่าวหนึ่งที่ทีมกลางวันเปิดงานตรวจ แต่กะกลางคืนข้ามไป ทั้งที่ CVE ตัวนั้นอยู่ใน KEV และระบบเห็นมันถึงสามรอบ เหตุผลที่ LLM ตอบกลับมาคือ "ผลิตภัณฑ์นี้ไม่อยู่ใน watchlist" ซึ่งถูกต้องตามข้อมูลที่มันได้รับ ปัญหาจริงจึงอยู่ที่ watchlist ไม่ใช่ prompt หรือโมเดล

สิ่งที่เราทำต่อจากนั้นคือ

  • เพิ่มผลิตภัณฑ์นั้นลง watchlist ผ่าน Git ตามขั้นตอนปกติ แล้วให้ drift check ยืนยันว่า deploy แล้ว
  • เทียบผลกะกลางคืนกับงานที่ทีมกลางวันเปิดทุกเช้า นับเป็น matched/missed และบันทึกต้นเหตุของทุก miss ว่าเกิดจาก watchlist, inventory, pre-filter หรือการตัดสินของโมเดล
  • ทบทวน watchlist เทียบกับ รายการระบบและเจ้าของ เป็นระยะ เพราะ watchlist ที่ดีควรสะท้อน inventory ไม่ใช่ความจำของคนเขียน

ฝั่งตรงข้ามก็ต้องระวังเหมือนกัน ชั้น name_mention ดึงซอฟต์แวร์ของบุคคลที่สามที่แค่ "เอ่ยถึง" ผลิตภัณฑ์ของเราเข้ามาด้วย คืนแรกมี false positive สองรายการจากชั้นนี้ เราจึงให้ verifier ที่เป็นโค้ดตรวจ product identity จากข้อมูล affected ของ CNA ด้วย ถ้า CNA ระบุชัดว่าเป็นผลิตภัณฑ์อื่น ก็ให้ตัดสินว่าไม่กระทบ

ตัวเลขที่ควรดูทุกเช้า

  • drop_counts แยกตามเหตุผล และแนวโน้มเทียบกับคืนก่อน
  • rescue: ตัดสินไปกี่รายการ เกี่ยวข้องจริงกี่รายการ ด่วนกี่รายการ แยกตาม tier
  • cap hit กี่ครั้ง ล้นกี่รายการ carry ไปกี่รายการ และมีรายการที่ทิ้งจริงหรือไม่ (ควรเป็นศูนย์)
  • drift: in sync / drift / error
  • matched/missed เทียบกับทีมกลางวัน พร้อมต้นเหตุของแต่ละ miss

จากคืนแรก รายการที่ผ่าน rescue ส่วนใหญ่ไม่เกี่ยวกับเรา มีส่วนน้อยที่เกี่ยวข้องจริง และยังไม่มีตัวไหนด่วน ฟังดูเหมือนไม่คุ้ม แต่จุดประสงค์ของ rescue path ไม่ใช่การเจอของเยอะ มันคือการพิสูจน์ได้ว่าไม่มีอะไรหายไปโดยไม่มีร่องรอย และต้นทุนก็ถูกคุมไว้ด้วย cap กับงบเวลาเดิมอยู่แล้ว

กับดักที่เจอ

  • เก็บ carry-over เฉพาะรายการในคิว แต่ลืมรายการที่ล้น cap ตั้งแต่ตอนจัดคิว
  • ให้ rescue ใช้งบเวลาแยก จนรอบที่มี CVE เยอะลากยาวไปชนรอบถัดไป
  • ปล่อยให้ชั้นที่มีเสียงรบกวนสูง (kernel หรือ Medium จำนวนมาก) แย่งโควตาชั้นที่น่าเชื่อถือกว่า
  • เชื่อ watchlist บนเครื่องเป็นความจริงเพียงแหล่งเดียว ทั้งที่อาจค้างรุ่นเก่า
  • แก้ prompt เมื่อเจอ miss ทั้งที่ต้นเหตุคือข้อมูลขาเข้า
  • ให้ drift check แก้ไฟล์เอง หรือพิมพ์เนื้อหา config ลงรายงาน

สรุป

pre-filter เป็นสิ่งจำเป็น แต่ต้องไม่เป็นหลุมดำ ให้ทุกการทิ้งมีเหตุผลและถูกนับ ส่งรายการที่มีสัญญาณไปดูซ้ำตามชั้นความน่าเชื่อถือ คุมต้นทุนด้วย cap กับงบเวลาเดิม และทำ carry-over ให้ครอบคลุมทุกทางที่รายการอาจหลุด จากนั้นตรวจ drift ของ config ทุกรอบ แล้วเทียบผลกับสิ่งที่คนเจอเพื่อแก้ที่ต้นเหตุ

บทเรียนที่ชัดที่สุดของเราคือ ชื่อ feature ว่า "no silent drop" ไม่ได้รับประกันอะไร ถ้าไม่มีตัวเลขในรายงานที่พิสูจน์ได้ทุกเช้าว่าของที่ล้นทั้งหมดไปอยู่ที่ไหน ถ้าคุณกำลังสแกนหาแพ็กเกจที่โดน CVE ในหลาย repo ก็ใช้หลักเดียวกันได้ ดูตัวอย่างได้ใน บทความเรื่องสแกน repo แบบอ่านอย่างเดียว