ทีม infra ส่วนใหญ่รู้ดีว่าเครื่องข้างในมีอะไรบ้าง แต่ถ้าถามว่า "คนนอกที่ไม่มีบัญชีอะไรเลย มองเห็นบริษัทเราแค่ไหน" คำตอบมักเป็นการเดา subdomain ที่เคยใช้ทดสอบแล้วลืมลบ ใบรับรองที่ใกล้หมดอายุบนเครื่องที่ไม่มีใครดูแล โดเมนหน้าคล้ายที่มีคนจดไว้ พอร์ตฐานข้อมูลที่เผลอเปิดตอนย้ายเครื่อง หรือ token ที่เคย commit ลง Git เมื่อสามปีก่อน ทั้งหมดนี้เป็นข้อมูลที่ผู้โจมตีหาได้ฟรีจากอินเทอร์เน็ต

บทความนี้สรุปวิธีสร้าง exposure monitor รายวัน แบบที่ใช้เครื่องมือ open source และบริการฟรี รันบนเครื่องเดียว โดยแยกรอบแรกที่ต้องไล่ประวัติทั้งหมดออกจากรอบรายวันที่ดูเฉพาะสิ่งที่เปลี่ยน ตัวอย่างใช้โดเมน example.com และช่วง IP 192.0.2.0/24 ทั้งหมด ตัวเลขและชื่อในบทความเป็นตัวอย่าง ไม่ได้คัดลอกจากระบบที่ใช้อยู่จริง

แผนภาพ exposure monitor รายวัน ซ้ายคืออินพุตที่เป็นของบริษัทเอง ได้แก่โดเมน ช่วง IP และ Git ภายใน ตรงกลางคือแปดโมดูล ได้แก่ subdomain จาก Certificate Transparency, TLS, พอร์ตที่เปิด, SPF DKIM DMARC, โดเมนหน้าคล้าย, โค้ดสาธารณะ, ความลับใน Git และ infostealer ขวาคือฐานข้อมูล findings ที่ใช้คีย์คงที่ และหน้ารายงานส่วนตัวที่แยก NEW SEEN และ GONE ด้านล่างคือกฎที่ไม่ข้าม เช่น ไม่ดาวน์โหลดข้อมูลรั่วและไม่ลอง credential
ภาพรวม: เริ่มจากรายชื่อสิ่งที่เป็นของเราแน่ ๆ รันแปดโมดูลวันละครั้ง เก็บผลด้วยคีย์คงที่ แล้วแสดงเฉพาะสิ่งที่เปลี่ยน (คลิกที่ภาพเพื่อดูขนาดเต็ม)

ตั้งเส้นที่ไม่ข้ามก่อนเขียนโค้ด

exposure monitor ทำงานใกล้เส้นแบ่งระหว่าง "ตรวจตัวเอง" กับ "ทำตัวเหมือนผู้โจมตี" มาก จึงควรเขียนกฎไว้ใน README ตั้งแต่วันแรก และให้โค้ดบังคับกฎนั้นเอง ไม่ใช่พึ่งความระมัดระวังของคนรัน กฎที่เราใช้มีดังนี้

  • สแกนเฉพาะสิ่งที่เป็นของเรา รายชื่อโดเมนและช่วง IP อยู่ในไฟล์ config ที่ผ่านการรีวิว ไม่ใส่โดเมนของลูกค้าแม้จะเป็นคนดูแลระบบให้ก็ตาม เพราะนั่นต้องมีข้อตกลงแยก
  • ไม่ดาวน์โหลดชุดข้อมูลที่รั่ว ใช้เฉพาะบริการที่ตอบว่า "เจอหรือไม่เจอ" พร้อม metadata
  • ไม่ลอง credential และไม่ทดสอบว่า secret ยังใช้ได้ไหม ถ้าเจอให้ถือว่ารั่วแล้ว แล้วไปเปลี่ยนที่ต้นทาง
  • ไม่ยิง exploit หรือ vuln probe งานนี้คือการสำรวจพื้นผิว ไม่ใช่ pentest
  • ไม่เก็บค่าความลับ เก็บแค่ว่าเจอ rule อะไร ไฟล์ไหน commit ไหน
  • หน้ารายงานเห็นได้คนเดียวหรือทีมเล็ก เพราะรายการ finding ก็คือแผนที่จุดอ่อนของบริษัท

ขั้นที่ 1: เริ่มจาก inventory ที่ยืนยันแล้ว

config มีแค่ไม่กี่อย่าง และไม่มีความลับอยู่ในนั้นเลย จึงเก็บใน Git ได้

{
  "domains":        ["example.com", "example.net"],
  "own_cidrs":      ["192.0.2.0/24"],
  "parking_cidrs":  ["203.0.113.0/24"],
  "expected_cert_issuers": ["Let's Encrypt", "Sectigo"],
  "dkim_selectors": ["default", "google", "selector1", "selector2"],
  "lookalike_ignore": ["example-cdn.net"],
  "tls_warn_days": 21
}

ส่วน token ของ Git ภายใน รหัสผ่านหน้ารายงาน และรายชื่ออีเมลพนักงาน แยกไปอยู่ในไฟล์ที่ root อ่านได้คนเดียว (mode 600) และใส่ไว้ใน .gitignore ตั้งแต่ commit แรก

ขั้นที่ 2: หา subdomain จาก Certificate Transparency

ทุกใบรับรองที่ CA ออกให้จะถูกบันทึกลง Certificate Transparency (CT) log ซึ่งค้นได้สาธารณะ ผู้โจมตีใช้ช่องทางนี้หา subdomain เป็นอย่างแรก เราจึงควรใช้ก่อน ค้นด้วย %.example.com บน crt.sh แล้วนำชื่อทั้งหมดไป resolve DNS

บทเรียนแรกคือ crt.sh ล่มหรือ timeout บ่อย โดยเฉพาะโดเมนที่มีใบรับรองเยอะ ถ้าสคริปต์พังทั้งรอบทุกครั้งที่ crt.sh ช้า รายงานจะว่างหลายวันโดยไม่มีใครรู้ เราจึง retry สามครั้ง ถ้ายังไม่ได้ก็ fallback ไปใช้ API ของ CT อีกเจ้า และบันทึกไว้ในรายงานว่ารอบนี้ใช้แหล่งไหน

เมื่อได้รายชื่อ host แล้ว มีสามอย่างที่ควรแจ้งเป็น high ทันที

  • CNAME ค้าง ชื่อของเรายังชี้ไปที่ปลายทางที่ resolve ไม่ได้แล้ว เช่น bucket หรือ app บน cloud ที่ลบไปแล้ว ถ้าคนอื่นจดชื่อปลายทางนั้นได้ ก็จะได้ subdomain ของเราไปด้วย (subdomain takeover)
  • ชี้ไปที่ network ของบริการ domain parking มักเป็นสัญญาณว่าโดเมนปลายทางหมดอายุและถูกคนอื่นเก็บไป
  • ใบรับรองที่ออกโดย CA ที่เราไม่ได้ใช้ ไม่ได้แปลว่าโดนโจมตีเสมอไป อาจเป็นทีมอื่นที่ใช้ SaaS แต่ควรมีคนยืนยันว่า "ใช่ เราเอง"

จากนั้นต่อ TLS กับทุก host ที่ resolve ได้ อ่านวันหมดอายุและเช็กว่าชื่อตรงกับ SAN หรือไม่ ใบที่เหลือน้อยกว่า 21 วันเป็น medium และใบที่หมดแล้วเป็น high สิ่งนี้ดูธรรมดา แต่ช่วยกันเว็บล่มเพราะใบรับรองหมดอายุบนเครื่องที่ไม่มีใครจำได้

ขั้นที่ 3: สแกนพอร์ตเฉพาะ IP ที่เป็นของเราเอง

อย่าสแกนทุก IP ที่ชื่อของเรา resolve ไป เพราะหลาย host อยู่หลัง CDN, load balancer ของ cloud หรือ SaaS ซึ่งไม่ใช่ของเรา การสแกนพวกนั้นอาจผิดข้อตกลงการใช้บริการ ให้เอาเฉพาะ IP ที่อยู่ใน own_cidrs แล้วสแกนแบบสุภาพ

nmap -sT -Pn -n --top-ports 200 -T3 --max-rate 20 \
     --max-retries 1 --host-timeout 10m -oX - 192.0.2.10 192.0.2.11

# รอบที่สอง: พอร์ตที่ไม่ควรเปิดสู่อินเทอร์เน็ตเลย
nmap -sT -Pn -n -p 21,23,445,1433,2375,3306,3389,5432,5900,6379,9200,27017 \
     -T3 --max-rate 20 --max-retries 1 -oX - 192.0.2.10 192.0.2.11

เหตุที่แยกเป็นสองรอบ เพราะถ้าใช้ --top-ports คู่กับ -p ในคำสั่งเดียว nmap จะไม่ได้สแกนครบตามที่เราคิด พอร์ตในรายการที่สอง (ฐานข้อมูล, RDP, Docker API, Redis, Elasticsearch และอื่น ๆ) ถ้าเปิดให้เป็น high เสมอ ส่วนพอร์ตอื่นเก็บเป็น info ไว้ดูว่ามีอะไรเพิ่มขึ้นมาใหม่ หลังพบแล้วให้ไปปิดที่ firewall หรือ security group แทนการไล่ปิดที่ service ทีละตัว ถ้าเว็บที่เปิดอยู่ยังไม่มี security headers ดูแนวทางต่อได้ใน ตั้ง security headers ให้มีเจ้าของชั้นเดียว

ขั้นที่ 4: ตรวจ SPF, DKIM และ DMARC

โดเมนที่ไม่มี DMARC หรือมีแต่ p=none คือโดเมนที่ใครก็ปลอมเป็นผู้ส่งได้ และเป็นช่องทาง phishing ที่ถูกที่สุด การตรวจนี้ใช้แค่ DNS ไม่ต้องส่งอีเมลจริง

dig +short TXT example.com        | grep -i 'v=spf1'
dig +short TXT _dmarc.example.com | grep -i 'v=dmarc1'
dig +short TXT default._domainkey.example.com

กฎที่ใช้จัดระดับความรุนแรงมีดังนี้

  • ไม่มี SPF หรือไม่มี DMARC บนโดเมนที่มี MX เป็น high และเป็น medium ถ้าโดเมนนั้นไม่ได้ใช้ส่งเมล
  • SPF มีมากกว่าหนึ่ง record ถือเป็น permerror ซึ่งผู้รับหลายรายจะมองว่าไม่มี SPF เลย
  • SPF ที่ลงท้ายด้วย +all หรือ all เฉย ๆ เป็น high เพราะอนุญาตทุกคน ส่วน ?all เป็น medium และ ~all เป็น low
  • DMARC p=none เป็น medium และ DMARC ที่ไม่มี rua= เป็น low เพราะเราจะไม่รู้เลยว่าใครส่งเมลในนามเรา
  • โดเมนที่ไม่ส่งเมลเลยควรมี null MX (MX 0 . ตาม RFC 7505) และ v=spf1 -all

DKIM ตรวจได้ยากกว่า เพราะต้องรู้ชื่อ selector ก่อน ถ้าลองชื่อที่ใช้กันทั่วไปแล้วไม่เจอ ให้บันทึกเป็น "ไม่พบใน selector ที่รู้จัก" ไม่ใช่ "ไม่มี DKIM" แล้วให้คนที่ดูแลเมลยืนยันอีกที รอบแรกมักเจอทั้งโดเมนที่ส่งเมลจริงแต่ DMARC ยังเป็น p=none และโดเมนที่ไม่ได้รับเมลแต่ยังไม่มี SPF, DMARC หรือ null MX ทั้งสองกรณีเป็นเรื่องที่คนดูแลโดเมนต้องตัดสินใจ ไม่ใช่ให้สคริปต์ไปแก้ DNS เอง

ขั้นที่ 5: ตามโดเมนหน้าคล้าย

dnstwist สร้างโดเมนที่สะกดคล้ายของเรา ทั้งพิมพ์ผิด สลับตัวอักษร ตัวอักษรหน้าตาเหมือน และเปลี่ยน TLD แล้วเช็กว่าโดเมนไหนถูกจดไว้แล้ว

dnstwist --registered --format json -t 8 example.com > lookalikes.json

อย่าเปิด option ที่ส่ง SMTP ไปถามเซิร์ฟเวอร์ของคนอื่น แค่ DNS ก็พอ แล้วจัดระดับจากสิ่งที่โดเมนนั้นทำได้จริง ถ้ามี MX แปลว่ารับเมลได้ หรือมีเว็บที่ไม่ใช่หน้า parking ให้เป็น high เพราะพร้อมใช้ phishing ส่วนโดเมนที่จดไว้เฉย ๆ เป็น low

noise ก้อนใหญ่ในรอบแรก ๆ มาจาก fuzzer แบบแทรกจุด เช่น examp.le.com จะกลายเป็น subdomain ของโดเมน le.com ซึ่งเป็นของคนอื่นที่ไม่เกี่ยวกับเราเลย เราจึงลดรายการพวกนี้เป็น low เมื่อไม่มี MX นอกจากนี้ยังค้น CT ด้วยคำที่เป็นชื่อแบรนด์ เพื่อหาใบรับรองที่ออกให้ชื่ออย่าง example-login.net ซึ่ง dnstwist ไม่ได้สร้างให้

ขั้นที่ 6: ไล่หาความลับใน Git โดยไม่เก็บค่าความลับ

สำหรับ Git ภายใน ใช้ token ที่มีแค่ read_repository ทำ mirror ของทุก project แล้วรัน gitleaks บนประวัติทั้งหมด ข้อสำคัญคือ token ต้องไม่ไปอยู่ใน URL ของ remote เพราะจะติดไปกับ git config และข้อความ error ให้ส่งผ่าน GIT_ASKPASS ที่อ่านค่าจาก environment แทน

#!/bin/sh
# askpass.sh : git จะเรียกสคริปต์นี้ตอนต้องการ username/password
case "$1" in
  Username*) echo "oauth2" ;;
  *)         echo "$EM_GIT_TOKEN" ;;
esac
gitleaks git mirror.git --no-banner --redact=100 \
  --report-format json --report-path /tmp/r.json \
  --max-target-megabytes 5 --log-opts "--all --not $PREV_REFS"

--redact=100 ทำให้ค่าในรายงานถูกปิดทั้งหมด และโค้ดของเรายังทิ้งฟิลด์ Secret, Match และ Line ก่อนบันทึกด้วย เก็บไว้แค่ rule, ไฟล์, บรรทัด, commit และวันที่ ส่วน --log-opts "--all --not ..." ใช้รายการ ref ที่บันทึกไว้จากรอบก่อน ทำให้รอบถัดไปสแกนเฉพาะ commit ใหม่ รอบแรกที่ต้องไล่ประวัติทั้งหมดมักใช้เวลานานกว่าโมดูลอื่นรวมกันหลายเท่า อาจเป็นชั่วโมง ไม่ใช่ไม่กี่สิบนาที และควรมี timeout ต่อ repo ถ้าตัวใดหมดเวลา ให้บันทึกแล้วไปต่อ อย่าทำให้ทั้งรอบพัง ถ้ารอบถูกตัดกลางคัน รายการ ref ที่เขียนไปแล้วต้องเก็บไว้ รอบถัดไปจะข้าม repo ที่สแกนจบแล้ว แล้วกลับไปทำตัวที่ค้างหรือ timeout โดยไม่ต้องเริ่มจากศูนย์ รอบรายวันที่ repo ส่วนใหญ่ไม่มี commit ใหม่จะสั้นลงมาก แต่ถ้าวันไหนมี repo ใหญ่ที่มี commit ใหม่ ก็ยังอาจยืดได้อีก

เรื่องระดับความรุนแรง rule แบบ generic (คำว่า password หรือ api_key ใกล้กับ string ยาว ๆ) ให้ false positive เยอะมาก เราจึงแยกเป็นสองแกน

  • rule ที่จับรูปแบบเฉพาะของผู้ให้บริการ เช่น private key, cloud access key หรือ token ของ Git hosting และไฟล์นั้นยังอยู่ที่ HEAD เป็น critical ถ้าอยู่แค่ในประวัติเป็น high
  • rule แบบ generic เป็น medium ถ้ายังอยู่ที่ HEAD และเป็น low ถ้าอยู่แค่ในประวัติ

รอบแรกจะมีรายการกองใหญ่ โดยเฉพาะจาก rule แบบ generic และจากไฟล์ทดสอบหรือเอกสารที่ดูคล้ายความลับ ต้องมีสถานะให้คนอ่านคัดกรองได้ เช่น ack, fixed, not_relevant ไม่งั้นรายงานตอนเช้าจะใช้ไม่ได้ตั้งแต่สัปดาห์แรก อีกเรื่องคือโหมดข้าม repo ที่ไม่มี commit ใหม่จะอัปเดตแค่ last_scan ของรายการเดิม จะไม่จัดระดับความรุนแรงใหม่ ถ้าภายหลังปรับเกณฑ์ ต้องมีรอบที่บังคับสแกนใหม่

ความลับที่หลุดเข้า Git ไปแล้ว ต่อให้ลบออกจาก HEAD ก็ยังต้องถือว่ารั่ว วิธีแก้ที่ถูกคือ revoke หรือ rotate ที่ต้นทาง การเขียนประวัติ Git ใหม่เป็นขั้นที่ทำหรือไม่ทำก็ได้ ฝั่งโค้ดสาธารณะ ให้ค้นชื่อโดเมนของเราใน code search ของ GitHub และ GitLab.com โดยข้าม org ของเราเอง (code search ของ GitHub ต้องใช้ token แม้จะค้นโค้ดสาธารณะ) ถ้าอยากรู้ว่า repo ไหนใช้ library ที่มีช่องโหว่ด้วย ดูวิธีที่ใช้ token อ่านอย่างเดียวแบบเดียวกันได้ใน ไล่หาแพ็กเกจที่โดน CVE ใน Git หลายร้อย repo

ขั้นที่ 7: เช็ก infostealer แบบส่งข้อมูลให้น้อยที่สุด

ทุกวันนี้ credential รั่วจากเครื่องพนักงานที่ติดมัลแวร์ขโมยข้อมูล (infostealer) มากกว่าจากการเจาะเซิร์ฟเวอร์ บริการ OSINT บางเจ้ามี API ฟรีที่ตอบได้ว่าโดเมนหรืออีเมลนี้เคยพบใน log ของ infostealer หรือไม่ ถ้าจะใช้ ให้ทำตามนี้

  • ขออนุมัติก่อนว่ายอมส่งชื่อโดเมนและอีเมลบริษัทออกไปให้บริการภายนอกได้ไหม
  • ส่งแค่โดเมน หรืออีเมลทีละรายการ พร้อมเว้นช่วงระหว่าง request ไม่ส่งข้อมูลอื่น
  • whitelist ฟิลด์ที่จะเก็บ เช่น วันที่ติดมัลแวร์ ตระกูลมัลแวร์ และระบบปฏิบัติการ ส่วนรหัสผ่าน (แม้ถูก mask แล้ว) ชื่อเครื่อง และ IP ให้ทิ้งทั้งหมด
  • ถ้าเจอ ให้ตรวจเครื่องของคนนั้น เปลี่ยนรหัสผ่าน และ revoke session ทั้งหมด ไม่ต้องเอา credential ไปลองว่ายังใช้ได้ไหม

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

ขั้นที่ 8: เก็บผลด้วยคีย์คงที่ แล้วแสดงเฉพาะสิ่งที่เปลี่ยน

ถ้ารายงานทุกเช้ามีหลายร้อยบรรทัดที่หน้าตาเหมือนเมื่อวาน ภายในสัปดาห์เดียวก็จะไม่มีใครเปิดอ่าน หัวใจของระบบจึงไม่ใช่ตัวสแกน แต่เป็นการให้แต่ละ finding มี คีย์ที่คงที่ ซึ่งสร้างจากสิ่งที่ระบุตัวตนของปัญหา ไม่ใช่จากข้อความที่แสดง

def add(con, scan_id, module, severity, fkey, title, detail):
    row = con.execute("SELECT id FROM findings WHERE fkey=?", (fkey,)).fetchone()
    if row:
        con.execute("UPDATE findings SET last_seen=?, last_scan=?, severity=?, "
                    "title=?, detail=? WHERE id=?",
                    (now(), scan_id, severity, title, detail, row[0]))
    else:
        con.execute("INSERT INTO findings(fkey, module, severity, title, detail, "
                    "first_seen, last_seen, first_scan, last_scan) "
                    "VALUES(?,?,?,?,?,?,?,?,?)",
                    (fkey, module, severity, title, detail,
                     now(), now(), scan_id, scan_id))

# ตัวอย่างคีย์
#   dmarc-none:example.com
#   port:192.0.2.10:3306
#   tls-expiring:www.example.com:2026-12-01
#   gl:group/app:<gitleaks fingerprint>

เมื่อมี first_scan และ last_scan หน้ารายงานก็แยกได้ทันทีว่ารายการไหน NEW (เจอครั้งแรกในรอบนี้), SEEN (ยังอยู่) และ GONE (รอบนี้ไม่เจอแล้ว) ข้อควรระวังคือโมดูลที่สแกนแบบเฉพาะส่วนที่เปลี่ยน เช่น gitleaks ที่ข้าม repo ที่ไม่มี commit ใหม่ ต้อง "แตะ" finding เดิมของ repo นั้นให้ last_scan เป็นรอบปัจจุบันด้วย ไม่อย่างนั้นทุกอย่างจะกลายเป็น GONE ในรอบที่สอง ซึ่งเป็นบั๊กที่เกิดได้ง่ายมากถ้าไม่ได้คิดเผื่อไว้

อีกเรื่องคือ ให้แต่ละโมดูลรันใน try ของตัวเอง แล้วบันทึกสถานะ ok หรือ error พร้อมเวลาที่ใช้ลงในตาราง scans ถ้าโมดูลใดพัง รอบนั้นจะถูกบันทึกว่าเป็น partial แต่โมดูลอื่นยังทำงานต่อได้ และหน้ารายงานต้องแสดงสถานะนี้ให้เห็นชัด เพราะ "ไม่มี finding" กับ "โมดูลไม่ได้รัน" มีความหมายต่างกันมาก ถ้ารอบถูกฆ่าก่อนจบ แถวในตารางสแกนอาจค้างสถานะ running โดยไม่มีเวลาจบ ให้ยึดรอบล่าสุดที่สถานะเป็น ok อย่าไปลบ findings ที่เขียนไว้แล้วระหว่างทาง

ขั้นที่ 9: ตั้งเวลา และล็อกหน้ารายงาน

ใช้ systemd timer แทน cron เพื่อให้ได้ log ใน journal จำกัดทรัพยากรได้ และรันซ้ำได้เมื่อเครื่องเปิดกลับมาหลังพลาดรอบ

# /etc/systemd/system/exposure-monitor-scan.timer
[Timer]
OnCalendar=*-*-* 06:15:00
RandomizedDelaySec=300
Persistent=true

# /etc/systemd/system/exposure-monitor-scan.service (บางส่วน)
[Service]
Type=oneshot
User=exposure
Nice=10
IOSchedulingClass=idle
MemoryHigh=900M
MemoryMax=1.2G
TimeoutStartSec=5h
NoNewPrivileges=true
ProtectSystem=strict
ReadWritePaths=/var/lib/exposure-monitor

ลิมิตหน่วยความจำเป็นของหน่วยสแกน ไม่ใช่ของทั้งเครื่อง ถ้ายอดใช้ถึงเพดาน งานจะไปใช้ swap และช้าลงได้แม้เครื่องจะมี RAM เหลือ ควรวัด memory peak กับ swap ของ unit หลังรอบแรก แล้วค่อยตัดสินใจว่าจะคงลิมิตหรือขยาย อย่าขยายแค่เพราะดูว่าเครื่องยังว่าง นอกจากนี้รอบแรกจะสร้างคลัง mirror ของ Git บนดิสก์ ซึ่งโตเร็วกว่าฐานข้อมูล findings มาก ต้องเผื่อพื้นที่ไว้ และแยก cache นี้จากงานอื่นบนเครื่องเดียวกัน TimeoutStartSec ต้องยาวพอสำหรับรอบแรกที่ใช้เวลาเป็นชั่วโมง

หน้ารายงานเป็น HTTP server เล็ก ๆ ที่ bind เฉพาะ IP ของ VPN (เช่น 100.64.0.10 บน tailnet) ไม่มี hostname สาธารณะ มี basic auth และ path ที่เดาไม่ได้ ส่วน path อื่นตอบ 404 โดยไม่ขึ้นหน้าต่างขอรหัสผ่าน แนวคิดเดียวกับการ เปิดระบบให้เข้าได้เฉพาะทาง Tailscale และช่วงแรกไม่ต้องส่งแจ้งเตือนอัตโนมัติ ให้คนเปิดอ่านเองสักสองสามสัปดาห์ก่อน จนรู้ว่า noise มีแค่ไหน แล้วค่อยเลือกส่งเฉพาะ NEW ที่เป็น critical

บทเรียนจากรอบสแกนเต็มครั้งแรก

ก่อนตั้งให้รันทุกวัน ควรทำให้รอบแรกจบอย่างน้อยหนึ่งครั้ง แล้วค่อยเชื่อตัวเลขเวลาของตัวเอง จากรอบเต็มครั้งแรกมีบทเรียนที่ชัดดังนี้

  • โมดูลที่ไล่ประวัติ Git ทั้งหมดมักกินเวลาเกือบทั้งรอบ ส่วนโมดูลที่ถาม DNS, ใบรับรอง, พอร์ต, โดเมนหน้าคล้าย และบริการภายนอก รวมกันแล้วสั้นกว่ามาก อย่าวัดเวลาจากโมดูลเบาแล้วย้อมพอสำหรับทั้งระบบ
  • ถ้ารอบถูกตัดกลางคัน เพราะ timeout ของทั้งงาน หรือเพราะมีคนหยุด service findings และรายการ ref ต่อ repo ที่เขียนไปแล้วต้องยังอยู่ รอบถัดไปจึงข้าม repo ที่สแกนจบแล้ว กลับไปทำตัวที่ค้าง และไม่นับรอบที่ถูกฆ่าว่าเป็นรอบสำเร็จ
  • repo ขนาดใหญ่ควรมี timeout ของตัวเอง ถ้าตัวใดหมดเวลา ให้ไปต่อแล้วลองใหม่ในรอบถัดไป อย่าทำให้ทั้งงานล้ม
  • การจำกัดหน่วยความจำด้วย systemd ควรทำ แต่ต้องดูยอดใช้จริงของ unit ไม่ใช่แค่ RAM ว่างของเครื่อง ถ้ายอดถึงเพดานจนไปใช้ swap งานจะช้าลงโดยที่เครื่องดูว่างอยู่ วัดก่อน แล้วค่อยตัดสินใจว่าจะคงลิมิตหรือขยาย
  • รอบแรกสร้างคลัง mirror ของ Git บนดิสก์ ซึ่งโตเร็ว ต้องเผื่อพื้นที่ และอย่าใช้ cache ร่วมกับงานสแกนอื่น
  • รายงานรอบแรกจะเต็มไปด้วยรายการเก่า ไม่ใช่สิ่งที่เพิ่งเปลี่ยน เมื่อคัดกรองและทำเครื่องหมายแล้ว รอบเช้าต่อ ๆ ไปจะเริ่มแสดงเฉพาะรายการใหม่ตามที่ออกแบบไว้
  • บางโมดูลอาจให้ผลระดับโดเมนโดยไม่ชี้รายการย่อย เช่น สถิติ infostealer ของโดเมนทั้งโดเมน โดยที่อีเมลที่เช็กแล้วไม่ตรงรายการใด ให้นำเสนอตามที่มี อย่าเติมสมมติฐาน และอย่าไปลอง credential ที่รั่ว

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

  • ให้ทั้งรอบล้มเพราะแหล่งข้อมูลภายนอกเจ้าเดียวช้า ควร retry, fallback และบันทึกว่ารอบนี้ใช้แหล่งไหน
  • สแกนพอร์ตของ IP ที่เป็น CDN หรือ SaaS เพียงเพราะชื่อของเราชี้ไปที่นั่น
  • รวม --top-ports กับ -p ไว้ใน nmap คำสั่งเดียว แล้วคิดว่าสแกนครบแล้ว
  • ใส่ token ไว้ใน URL ของ git remote จนไปโผล่ใน error log ควร mask ค่า token ในทุกข้อความ error ก่อนเขียนลง log
  • เก็บผลของ gitleaks แบบไม่ redact ทำให้ฐานข้อมูลของ monitor กลายเป็นที่รวม secret เสียเอง
  • ใช้ข้อความหรือเวลาเป็นส่วนหนึ่งของคีย์ finding ทำให้ทุกอย่างเป็น NEW ทุกวัน
  • เพิ่มโดเมนของลูกค้าเข้าไป "เพราะดูแลให้อยู่แล้ว" โดยที่ยังไม่มีข้อตกลงเรื่องการสแกน
  • ประเมินเวลาจากโมดูลเบา แล้วเขียนว่าทุกรอบใช้เวลาไม่กี่สิบนาที ทั้งที่รอบแรกที่ไล่ประวัติ Git อาจใช้เวลาเป็นชั่วโมง
  • ดูแต่ RAM ว่างของเครื่อง แล้วขยายลิมิตของ unit โดยยังไม่ได้วัด memory peak กับ swap ของงานสแกนเอง
  • ลบ findings หรือ state ทิ้งเมื่อรอบถูกตัดกลางคัน ทำให้ต้องเริ่มไล่ประวัติใหม่ทั้งหมด
  • คิดว่ารายงานรอบแรกที่เต็มไปด้วยรายการเก่าจะใช้แทนรายงานสิ่งที่เปลี่ยนได้เลย โดยไม่มีขั้นตอนคัดกรอง

ถ้าภายหลังอยากให้ LLM ช่วยสรุปหรือจัดกลุ่ม finding ให้ใช้โมเดลที่ host เอง ส่งเฉพาะข้อมูลที่ redact แล้ว และเริ่มจากโหมดที่ให้แค่ข้อเสนอแนะ ไม่ให้ลงมือแก้เอง แนวทางอยู่ใน ให้ LLM ที่ host เองทำงานกะดึกแบบ shadow mode

สรุป

exposure monitor ที่ใช้ได้จริงไม่จำเป็นต้องซื้อ platform ราคาแพง เริ่มจาก inventory ของสิ่งที่เป็นของเราแน่ ๆ รันโมดูลง่าย ๆ ที่ดูจากมุมคนนอก ได้แก่ CT, TLS, พอร์ต, SPF/DKIM/DMARC, โดเมนหน้าคล้าย, ความลับใน Git และ infostealer โดยวางกฎที่ไม่ข้ามไว้ในโค้ด แล้วเก็บผลด้วยคีย์คงที่ เพื่อให้รายงานตอนเช้าบอกได้ว่าอะไรเปลี่ยนไปบ้าง

รอบแรกเป็นงานคนละแบบกับรอบรายวัน มันจะใช้เวลานานกว่า กินหน่วยความจำและพื้นที่ดิสก์มากกว่า และทิ้งรายการเก่าไว้ให้คัดกรอง เมื่อทำรอบนั้นจบ แล้วทำเครื่องหมายรายการที่ไม่ต้องลงมือแล้ว วันที่ไม่มีรายการ NEW เลย รายงานจะเหลือบรรทัดเดียว และนั่นคือสภาพที่ต้องการ ส่วนวันที่มีรายการขึ้นมา เราจะรู้ก่อนที่คนนอกจะเอาไปใช้