Dosfuscation คืออะไร? ทำไมเหล่านักพัฒนาจึงควรให้ความสนใจ
นี่คือภาพรวมของภัยคุกคามอย่างรวดเร็ว: ลองนึกภาพว่าคุณกำลังตรวจสอบ Pull Request (PR) ที่ดูเหมือนจะเป็นการอัปเดตยูทิลิตี้เล็กๆ น้อยๆ แต่ภายในนั้น ผู้ร่วมพัฒนาได้เพิ่มสคริปต์ช่วยเหลือที่ดูเหมือนไม่มีอันตรายใดๆ แต่เมื่อรวมโค้ดแล้ว สคริปต์นั้นจะทำงานระหว่างกระบวนการ CI (Continuous Integration) pipeline และก่อให้เกิดลูปที่ใช้หน่วยความจำทั้งหมดโดยไม่แจ้งให้ทราบล่วงหน้า ส่งผลให้การสร้างโปรแกรมล้มเหลว
Dosfuscation คือการโจมตีแบบปฏิเสธการให้บริการ (DoS) ภายในประเภทหนึ่งที่ปลอมแปลงโดยใช้เทคนิคการปกปิดโค้ด มันผสมผสานตรรกะที่ออกแบบมาเพื่อหยุดการทำงาน เช่น ลูปอนันต์หรือการใช้หน่วยความจำมากเกินไป เข้ากับกลยุทธ์ที่ซ่อนพฤติกรรมที่แท้จริง ทำให้ตรวจจับได้ยากในระหว่างการตรวจสอบหรือการตรวจตรา นี่ไม่ใช่ปัญหาจากภายนอก แต่มันอยู่ภายในโค้ดของคุณแล้ว และกำลังรอที่จะทำให้การสร้างหรือการใช้งานจริงของคุณล้มเหลว
ทำไมต้องสนใจ? ต่างจากการโจมตีแบบปฏิเสธการให้บริการ (Denial of Service) แบบดั้งเดิมที่ทำให้เซิร์ฟเวอร์ของคุณเต็มไปด้วยปริมาณการรับส่งข้อมูล การโจมตีแบบ Dosfuscation นั้นซ่อนตัวอยู่ได้อย่างแนบเนียน มักผ่านการตรวจสอบโค้ดหรือการตรวจสอบแพ็กเกจไปได้ มันคือระเบิดตรรกะที่ฝังอยู่ในโค้ดของคุณ pipeline.
ตัวอย่างจริง: An แพ็คเกจ npm มันมีลูปอนันต์ที่ปลอมแปลงไว้ มันติดตั้งได้ราบรื่น แต่ใช้หน่วยความจำมากเกินไปในเวอร์ชันใช้งานจริงจนแอปของคุณล่ม นี่แสดงให้เห็นว่าการโจมตีแบบ DoSfuscation ซึ่งใช้เทคนิคการปกปิดข้อมูล กลายเป็นรูปแบบที่ซ่อนเร้นของการโจมตีแบบปฏิเสธการให้บริการที่สร้างความเสียหายมากที่สุด
ปริมาณยาที่ใช้โดยทั่วไป (DoS) เทียบกับปริมาณยาที่ทำให้สับสน (Doscation): ความแตกต่างที่แท้จริงในด้านความเสี่ยง
Dosfuscation เป็นประเภทย่อยของการโจมตีแบบปฏิเสธการให้บริการ (Denial-of-Service) โดยแตกต่างจากการโจมตีแบบปฏิเสธการให้บริการแบบดั้งเดิมตรงที่มันทำงานภายในโดยใช้โค้ดที่ปกปิดซ่อนเร้น ไม่ใช่การรับส่งข้อมูลผ่านเครือข่าย
ลองนึกภาพดู: คุณอนุมัติ Pull Request (PR) ใน GitHub การทดสอบผ่าน การสร้างเริ่มขึ้น จากนั้น Runner ของคุณก็ค้าง คุณกำลังดีบั๊กงาน GitHub Actions ที่ล้มเหลวซึ่งหมดเวลาอยู่เรื่อยๆ ปรากฏว่า เพย์โหลดที่ถูกซ่อนไว้ในไลบรารีรองตัวหนึ่งทำให้เกิดลูปไม่สิ้นสุดในสคริปต์หลังการติดตั้งนั่นเอง
เมื่อนักพัฒนาคิดถึงการโจมตีแบบปฏิเสธการให้บริการ พวกเขามักจะนึกถึงสถานการณ์จากภายนอกเข้ามาภายใน เช่น กลุ่มคำขอที่เป็นอันตรายจำนวนมากที่โจมตี API หรือบอทเน็ตที่ใช้แบนด์วิดท์จนหมด นี่คือรูปแบบการโจมตีแบบปฏิเสธการให้บริการแบบคลาสสิก และส่วนใหญ่เราก็พร้อมรับมือกับมัน เรามี WAF (Ware-Aided Function) ที่ใช้การจำกัดอัตรา และสร้างโครงสร้างพื้นฐานที่ปรับขนาดได้ซึ่งสามารถรองรับการโจมตีได้
อย่างไรก็ตาม การบิดเบือนข้อมูลไม่ได้มาจากภายนอก มันฝังตัวอยู่ภายในโค้ดของคุณโดยตรง มันซ่อนอยู่ในส่วนประกอบต่างๆ และเล็ดลอดผ่านระบบ CI ไปได้ pipelineและรอจนกว่าจะถึงขั้นตอนการดำเนินการจึงค่อยระเบิดทุกอย่าง ไม่ว่าจะปรับแต่งไฟร์วอลล์อย่างไรก็ตาม การบรรเทา DDoS จะหยุดการทำงานเพราะมันไม่เคยเดินทางผ่านเครือข่าย มันอยู่ที่บ้านแล้ว
นี่จึงทำให้การโจมตีแบบ Dosfuscation เป็นรูปแบบการโจมตีแบบปฏิเสธการให้บริการที่แนบเนียนเป็นพิเศษ มันไม่ประกาศตัวด้วยสัญญาณรบกวนทางเครือข่าย มันจะทำลายระบบจากภายใน ตั้งแต่ขั้นตอนการสร้าง ในระหว่างการทำงาน หรือเมื่อมีการเรียกใช้ส่วนของตรรกะที่เฉพาะเจาะจง และเนื่องจากมันถูกซ่อนอยู่ในโค้ดโดยใช้เทคนิคการปกปิดขั้นสูง คุณจะไม่พบมันเว้นแต่คุณจะตรวจสอบอย่างละเอียด
นั่นเป็นเหตุผลที่ ทีม DevSecOps จำเป็นต้องคิดให้ไกลกว่าการป้องกันรอบนอก การรักษาความปลอดภัยในระดับแอปพลิเคชันมีความสำคัญไม่แพ้กัน หากคุณมุ่งเน้นแต่การป้องกันทราฟฟิกที่ไม่พึงประสงค์ คุณจะพลาดภัยคุกคามที่ซ่อนอยู่ในที่เก็บข้อมูลของคุณ
วิธีที่ผู้โจมตีใช้การเข้ารหัสแบบปกปิดเพื่อซ่อนตรรกะการโจมตีแบบ DoS ในโค้ด
คุณอาจเห็นสิ่งนี้เกิดขึ้นจริงเมื่อกระบวนการทำงานเริ่มใช้เวลานานกว่าที่คาดไว้ หรือแย่กว่านั้นคือไม่เสร็จสิ้นเลย ตัวอย่างหนึ่งคือทีมที่ทำการทดสอบในคอนเทนเนอร์ Docker ผ่านทาง... การกระทำของ GitHubมีการเพิ่มตัวช่วยทดสอบ JavaScript ขนาดเล็กผ่านโมดูลของบุคคลที่สาม โค้ดถูกเข้ารหัสเพื่อปกปิดลูปการจัดสรรหน่วยความจำที่ไม่สิ้นสุดซึ่งทำให้กระบวนการ Node.js หยุดทำงาน
โค้ดโจมตี DoS ที่เข้ารหัสซ่อนเร้นมักเล็ดลอดผ่านเวิร์กโฟลว์ CI ไปได้โดยไม่ถูกตรวจพบ ตัวอย่างเช่น GitHub Actions pipeline อาจเรียกใช้สคริปต์ที่ดูเหมือนไม่มีอันตรายใดๆ แต่จู่ๆ ก็ทำให้ระบบค้างเนื่องจากมีลูปไม่สิ้นสุดอยู่ภายใน
เพื่อให้เห็นภาพชัดเจนขึ้น นี่คือตัวอย่างของเพย์โหลดที่ถูกซ่อนไว้เพื่อโจมตีในโค้ดทั่วไป
ตัวอย่าง JavaScript: ลูปอนันต์ที่ซ่อนอยู่

วิธีนี้จะใช้หน่วยความจำอย่างไม่มีที่สิ้นสุดโดยใช้ตรรกะที่ซ่อนเร้น ซึ่งในที่สุดจะทำให้แอปพลิเคชันหยุดทำงาน
ตัวอย่าง Python: การกิน CPU ที่ถูกซ่อนไว้
import base64
exec(base64.b64decode("d2hpbGUgVHJ1ZToKICBhcCA9IFtdCiAgZm9yIGkgaW4gcmFuZ2UoMTAwMDAwMDApOgogICAgYXAucHVzaChzdHIoaSkp"))
ลูปที่เข้ารหัสแบบ base64 นี้ทำงานไปเรื่อยๆ อย่างไม่มีที่สิ้นสุด โดยใช้หน่วยความจำจำนวนมากโดยที่ดูไม่น่าสงสัยในตอนแรก
ที่ซ่อนของข้อมูลสำคัญ: สถานการณ์การปลอมแปลงข้อมูลในโลกแห่งความเป็นจริง
มัลแวร์ที่ปลอมแปลงมักซ่อนตัวอยู่ต่อหน้าต่อตา เช่น ภายในแพ็กเกจของบุคคลที่สาม หรือซอฟต์แวร์โอเพนซอร์ส pull requestsหรือสคริปต์ภายในที่นำกลับมาใช้ซ้ำโดยไม่ตรวจสอบ ผู้โจมตีอาศัยความเร็วในการพัฒนาและระบบอัตโนมัติเพื่อแทรกซึมเข้าไปโดยไม่ทันสังเกต และฝังระเบิดตรรกะไว้ในระบบของคุณอย่างลึกซึ้ง pipeline.
สถานการณ์ในโลกแห่งความเป็นจริงจะช่วยอธิบายให้เห็นภาพว่าสิ่งนี้เกิดขึ้นได้อย่างไร:
คุณกำลังใช้ GitHub Actions เพื่อเรียกใช้เวิร์กโฟลว์ CI ของคุณ .github/workflows/build.yml ติดตั้งส่วนประกอบที่จำเป็นของโปรเจ็กต์ หนึ่งในนั้นคือแพ็กเกจ npm แบบส่งต่อ ซึ่งไม่ได้ติดตั้งโดยคุณโดยตรง แต่เป็นส่วนประกอบที่จำเป็นของส่วนประกอบที่จำเป็นอีกทีหนึ่ง แพ็กเกจนี้อ้างว่าช่วยในเรื่องง่ายๆ เช่น การจัดการสตริง
แต่ภายในแพ็กเกจนั้น มีระเบิดตรรกะซ่อนอยู่ โดยใช้เทคนิคการปกปิดข้อมูล มันอาจเป็นลูปการจัดสรรหน่วยความจำที่ไม่สิ้นสุดซึ่งถูกกระตุ้นขึ้นระหว่างการทำงานบางอย่าง หลังการติดตั้ง สคริปต์ หรือการนำเข้าขณะรันไทม์ในการทดสอบของคุณ มันจะอยู่ในสถานะไม่ทำงานจนกว่าจะมีการเรียกใช้งาน โดยไม่มีคำเตือนหรือแฟล็กการตรวจสอบใดๆ
จู่ๆ โปรแกรม CI runner ของคุณก็ล่ม CPU และหน่วยความจำทำงานผิดปกติ งานหมดเวลา การสร้างหรือการปรับใช้ล้มเหลว
นี่ไม่ใช่แค่สมมติฐาน เหตุการณ์ลักษณะนี้เคยเกิดขึ้นจริงแล้ว มันแสดงให้เห็นว่าการบิดเบือนข้อมูลใช้ประโยชน์จากความเชื่อมั่นในชุดเครื่องมือของคุณ โดยใช้ประโยชน์จากเวิร์กโฟลว์อัตโนมัติ การรวมโค้ดอย่างรวดเร็ว และการพึ่งพาทางอ้อม
โดยทั่วไปแล้ว ข้อมูลอันตรายเหล่านี้มักซ่อนอยู่ที่ไหน?
- แพ็กเกจจากผู้ให้บริการภายนอก: โดยเฉพาะจาก npm, PyPI หรือ Maven
- คำขอรวมโค้ดแบบโอเพนซอร์ส: โดยใช้ตรรกะที่แยบยลซ่อนเร้นอยู่ภายใต้การอัปเดตที่เป็นประโยชน์
- สคริปต์ภายใน: นำโค้ดตัวอย่างมาใช้ซ้ำโดยไม่มีการตรวจสอบหรือทบทวนอย่างเหมาะสม
ผู้โจมตีใช้การปกปิดโค้ดเพื่อชะลอการตรวจจับ โดยอาศัยการตรวจสอบโค้ดที่ไม่ละเอียดถี่ถ้วนและการอัปเดตการพึ่งพาอัตโนมัติในการดำเนินการส่วนที่เหลือ
วิธีตรวจจับการปลอมแปลงปริมาณยาในโค้ดและส่วนประกอบต่างๆ ของคุณ
ใช้การวิเคราะห์สถิตเพื่อค้นหาตรรกะที่ผิดปกติ
ใช้เครื่องมือที่:
- ตรวจจับเทคนิคการปกปิดข้อมูล เช่น การเปลี่ยนแปลงลำดับการทำงานของโปรแกรม หรือการสร้างสตริงขึ้นใหม่
- ตรรกะการทำงานของแฟล็กที่ซับซ้อนเกินไปสำหรับโมดูลแบบง่ายๆ
- เน้นฟังก์ชันหรือรูปแบบสคริปต์ที่คล้ายกับการโจมตีแบบปฏิเสธการให้บริการ (Denial of Service attacks)
ตรวจสอบการพึ่งพาของไฟล์ต่างๆ มากกว่าแค่การตรวจสอบเวอร์ชัน
อย่าหยุดแค่การตรวจสอบหมายเลขเวอร์ชัน:
- ลองดูที่โค้ดจริง ๆ สิ
- ให้ความสำคัญกับการตรวจสอบการอัปเดตแพ็กเกจล่าสุด
- ค้นหาสตริงที่เข้ารหัส ตรรกะที่ซ่อนอยู่ หรือเครื่องหมายการบิดเบือนความจริง
ตรวจสอบสิ่งที่น่าสงสัยด้วยตนเอง Pull Requests
ระวัง:
- การเปลี่ยนแปลงที่ซับซ้อนเกินไปในการอัปเดตที่เรียบง่าย
- ตรรกะที่ไม่ชัดเจนหรือไม่สามารถอ่านได้ในโค้ดใหม่
- PR ที่แนะนำเทคนิคการปกปิดข้อมูลที่รู้จักกันดี
การบิดเบือนความจริงเกิดขึ้นเมื่อทุกคนคิดว่า "มันเป็นแค่การเปลี่ยนแปลงเล็กน้อย"
วิธีป้องกันอาการสับสนขนาดยาที่อาจเกิดขึ้นกับคุณ CI/CD
ในสภาพแวดล้อม CI เช่น GitHub Actions, GitLab CI หรือ CircleCI การป้องกันหมายถึงการตั้งค่าการควบคุมที่ตรวจจับและบล็อกเพย์โหลดที่ซ่อนเร้นตั้งแต่เนิ่นๆ ตัวอย่างเช่น บังคับให้มีการตรวจสอบ Pull Request สำหรับเวิร์กโฟลว์ทั้งหมดที่มีสคริปต์เชลล์ หรือติดตั้งโปรแกรมป้องกันการคัดลอก hooksและติดตาม .yml pipeline การตั้งค่าสำหรับกิจกรรมของบุคคลที่สามที่ยังไม่ได้รับการตรวจสอบ
CI/CD เป็นสนามเด็กเล่นแห่งการหลอกลวง นี่คือวิธีควบคุมมัน:
- เพิ่มเครื่องมือสแกนไวรัสแบบคงที่ลงในทุก Pull Request และ Build
- ใช้เฉพาะแพ็กเกจจากแหล่งที่เชื่อถือได้และได้รับการตรวจสอบแล้วเท่านั้น
- ติดตามการใช้งานทรัพยากรในการสร้างโปรแกรม การเพิ่มขึ้นอย่างผิดปกติอาจหมายถึงตรรกะที่ซ่อนอยู่
- ตรวจสอบความเกี่ยวข้องของทุกรายการกับสิ่งที่ตรวจสอบแล้ว SBOM.
- ห้ามมิให้ใช้เทคนิคการปกปิดข้อมูลทั่วไปโดยไม่มีเหตุผลที่ระบุไว้เป็นลายลักษณ์อักษร
หมดปัญหา “ติดตั้งแล้วหวังผล” การป้องกันหมายถึงการมี guardrails ผสานรวมเข้ากับขั้นตอนการทำงานของคุณ การตรวจจับการปลอมแปลงข้อมูลตั้งแต่เนิ่นๆ จะช่วยป้องกันการโจมตีแบบปฏิเสธการให้บริการที่สร้างความเสียหายร้ายแรงที่สุดได้
บทบาทของ Xygeni: ตรวจจับความผิดพลาด Dosfuscation ก่อนที่จะเข้าสู่ขั้นตอนการผลิต
ไซเกนี ช่วยให้ทีม DevSecOps หยุดการโจมตีแบบ DoSfuscation ก่อนที่จะทำให้เกิดการหยุดทำงาน โดยการฝังระบบรักษาความปลอดภัยอัจฉริยะไว้ทั่วทั้งระบบ ขั้นตอนการพัฒนามีความเชี่ยวชาญในการตรวจจับเทคนิคการปกปิดข้อมูลและการบังคับใช้ตามนโยบาย guardrails ที่ป้องกันไม่ให้การโจมตีแบบปฏิเสธการให้บริการ (Denial-of-Service) ที่แฝงตัวเข้ามาถึงระบบการใช้งานจริง
ในบทวิจารณ์ประชาสัมพันธ์
Xygeni สแกนความแตกต่างของโค้ดเพื่อระบุสัญญาณของการปกปิดข้อมูล เช่น:
- การใช้งานของ ประเมิน หรือวิธีการดำเนินการแบบไดนามิกที่คล้ายคลึงกัน
- สตริงที่เข้ารหัสแบบ Base64 หรือเลขฐานสิบหก ซึ่งมีจุดประสงค์เพื่อซ่อนตรรกะการทำงาน
- การควบคุมการไหลของโปรแกรมที่น่าสงสัย เช่น ลูปที่ไม่เป็นธรรมชาติ หรือการแตกแขนงตรรกะที่ซับซ้อน
รูปแบบเหล่านี้จะกระตุ้นการแจ้งเตือนแบบเรียลไทม์ระหว่าง pull request การตรวจสอบ ไม่ว่าจะเป็นในโค้ดของบริษัทเองหรือโค้ดของบุคคลที่สาม ช่วยให้ผู้ตรวจสอบความปลอดภัยสามารถตรวจจับการบิดเบือนข้อมูลได้ตั้งแต่เนิ่นๆ
ระหว่างการวิเคราะห์ความสัมพันธ์
Xygeni ไม่เพียงวิเคราะห์ข้อมูลเมตาของแพ็กเกจเท่านั้น แต่ยังวิเคราะห์แหล่งที่มาที่แท้จริงของส่วนประกอบที่เพิ่มเข้ามาใหม่หรือที่ได้รับการอัปเดตด้วย มันตรวจจับตรรกะที่ถูกซ่อนไว้ภายในฟังก์ชันตัวช่วยหรือสคริปต์หลังการติดตั้ง และแจ้งเตือนแพ็กเกจที่มีความเสี่ยงสูง แม้ว่าแพ็กเกจเหล่านั้นจะดูเหมือนถูกต้องตามกฎหมายก็ตาม
ในช่วงเวลาการสร้างใน CI/CD Pipelines
Xygeni ตรวจสอบงาน CI เพื่อตรวจจับความผิดปกติในพฤติกรรม หากการสร้างงานใช้ CPU หรือหน่วยความจำมากผิดปกติ Xygeni จะติดตามหาต้นตอของความผิดปกติไปยังโค้ดหรือแพ็กเกจเฉพาะที่เพิ่งเพิ่มเข้ามาโดยอัตโนมัติ และจะเชื่อมโยงพฤติกรรมขณะทำงานกับผลการตรวจสอบแบบคงที่โดยอัตโนมัติ เพื่อตรวจจับภัยคุกคาม DoS ที่ซ่อนอยู่ก่อนที่จะขัดขวางการส่งมอบงาน
ในฐานะที่เป็นชั้นการบังคับใช้นโยบาย
คุณสามารถตั้งค่า Xygeni ให้บล็อกรูปแบบการโจมตีที่มีความเสี่ยงได้โดยตรง เช่น:
- ห้ามใช้การพึ่งพาที่รวมถึงโค้ดที่เข้ารหัสแบบ base64 หรือ ประเมิน
- ต้องขออนุมัติด้วยตนเองสำหรับสคริปต์หลังการติดตั้งทั้งหมด
- บังคับใช้กฎที่เข้มงวดอย่างยิ่งต่อการควบคุมการไหลของโปรแกรมที่ไม่ชัดเจนใน Pull Request หรือ CI Jobs
ด้วย Xygeni ระบบรักษาความปลอดภัยจึงทำงานเชิงรุกมากขึ้น Xygeni ช่วยให้ทีมมองเห็นภาพรวม ได้รับคำเตือนล่วงหน้า และบังคับใช้ในระดับนโยบายเพื่อต่อต้านเทคนิคการปกปิดข้อมูลที่ dosfuscation ใช้ ด้วยการผสานรวม Xygeni เข้ากับทุกขั้นตอน ไม่ว่าจะเป็น Pull Request (PR), การสแกนการพึ่งพา และการทำงานของ CI คุณจะสามารถตรวจจับภัยคุกคามได้ก่อนที่จะเกิดปัญหาในภายหลัง
ดังนั้น Dosfuscation จึงทำให้รหัสของคุณหันมาทำร้ายตัวคุณเอง
การปลอมแปลงเอกสารไม่ใช่แค่ความเสี่ยงทางทฤษฎี แต่เป็นวิธีการโจมตีที่เกิดขึ้นจริงและกำลังเพิ่มมากขึ้น ซึ่งเปลี่ยนกระบวนการพัฒนาของคุณให้กลายเป็นอาวุธ มันเจริญเติบโตได้ดีในช่องว่างระหว่างการปล่อยเวอร์ชันอย่างรวดเร็ว การติดตั้งอัตโนมัติ และห่วงโซ่การพึ่งพาที่ซับซ้อนเกินกว่าจะตรวจสอบด้วยตนเองได้ นี่ไม่ใช่แค่ปัญหาด้านความปลอดภัย แต่เป็นความท้าทายด้านวิศวกรรมซอฟต์แวร์ โค้ดโจมตีแบบปฏิเสธการให้บริการ (Denial-of-Service) ที่เข้ารหัสซ่อนเร้นจะหลีกเลี่ยงการป้องกันแบบดั้งเดิมโดยการฝังตัวเองลงในโค้ดโดยตรง ซึ่งไฟร์วอลล์และตัวกรองการรับส่งข้อมูลไม่สามารถเข้าถึงได้
สำหรับนักพัฒนาแล้ว ข้อสรุปนั้นง่ายมาก: ถ้าคุณเขียนโค้ด โปรดอนุมัติ pull requestsหรือจัดการ CI/CD pipelineคุณคือด่านหน้า การสร้างระบบที่ปลอดภัยไม่ได้หมายถึงแค่การเขียนโค้ดที่สะอาดเท่านั้น แต่ยังต้องการการมองเห็น การตรวจสอบ และการป้องกันที่ได้รับการสนับสนุนจากนโยบายในทุกขั้นตอนอีกด้วย pipeline.
อย่าใช้แค่เช็คลิสต์ ผสานการตรวจจับการปกปิดข้อมูลเข้ากับเวิร์กโฟลว์ของคุณ ระวังสตริง base64 ตรรกะแปลกๆ หรือการใช้งานทรัพยากร CI ที่เพิ่มขึ้นอย่างไม่คาดคิด ตรวจสอบไม่ใช่แค่เพียง... อะไร คุณติดตั้ง แต่ มันทำอะไร. รักษา pipeline การกำหนดค่าต่างๆ เช่น โค้ดที่ใช้ในการผลิต การทำงานแบบอัตโนมัติ guardrailsระบุสิ่งที่ดูผิดปกติ แม้ว่ามันจะ "ใช้งานได้" ก็ตาม
เพราะการทำให้สับสนไม่ตะโกน มันรออยู่ และถ้าคุณไม่มองหามัน มันก็จะเล็ดลอดเข้ามาได้







