วิธีลบ “รหัสที่ซ่อนอยู่” จาก ChatGPT และ LLM อื่นๆ

เนื่องจากโมเดลภาษาขนาดใหญ่ (LLM) สร้างโค้ดที่ใช้งานได้เพิ่มมากขึ้นและรวมเข้ากับขั้นตอนการพัฒนาและสแต็กตัวแทน จึงมีความเสี่ยงเพิ่มขึ้นที่ ซ่อนเร้น or ที่เป็นอันตราย คำสั่ง — ไม่ว่าจะฝังอยู่ในเอาต์พุตของโมเดล ฉีดผ่านหน้าเว็บหรือปลั๊กอินของบุคคลที่สาม หรือแนะนำระหว่างการฝึกโมเดล — อาจทำให้เกิดพฤติกรรมที่ไม่ปลอดภัยเมื่อมีการดำเนินการโค้ดนั้น

ตามรายงานของผู้ใช้ที่เผยแพร่ในชุมชนนักพัฒนา นักพัฒนาซอฟต์แวร์ประสบกับการสูญเสียข้อมูลอันเลวร้าย — ประมาณ ไฟล์ 800GB ถูกลบไปแล้วรวมทั้ง แอปพลิเคชัน CursorAI ทั้งหมด — หลังจากดำเนินการโค้ดที่สร้างขึ้นด้วยความช่วยเหลือจาก ราศีเมถุน 3 ขณะทำงานอยู่ภายใน เคอร์เซอร์เอไอ IDEเนื่องจากนักพัฒนาพึ่งพา LLM มากขึ้นในการสร้างโค้ด ผลที่ตามมาของสคริปต์ที่ไม่ได้รับการตรวจสอบหรือสคริปต์ที่ไม่ปลอดภัยจึงร้ายแรงมากขึ้น

ดังนั้นการทราบวิธีการตรวจจับและลบโค้ดอันตรายที่สร้างขึ้นโดย LLM จึงเป็นเรื่องสำคัญมาก

“รหัสที่ซ่อนอยู่” ในบริบทของ ChatGPT และ LLM คืออะไร

“รหัสที่ซ่อนอยู่” หมายความว่าอย่างไร?

“โค้ดที่ซ่อนอยู่” เป็นคำศัพท์ทั่วไปที่นักพัฒนาใช้เพื่ออธิบายคำสั่งที่ฝังอยู่หรือเนื้อหาที่ปฏิบัติการได้ภายในข้อความ (หรือไฟล์) ที่ LLM รวบรวมหรือส่งออก รวมถึง:

• คำแนะนำแบบพรอมต์ ฝังอยู่ภายในเนื้อหาของผู้ใช้ (เช่น "ละเว้นคำแนะนำก่อนหน้านี้..." ซ่อนอยู่ใน PDF)
• ตัวละครที่มองไม่เห็น หรือช่องว่างความกว้างเป็นศูนย์ที่ใช้เพื่อซ่อนโทเค็นหรือทำลายสมมติฐานการสร้างโทเค็น
• เพย์โหลดที่เข้ารหัส (base64, เข้ารหัส URL, การฝังแบบสเตกาโนกราฟิกภายในรูปภาพหรือเอกสาร)
• ซ่อน HTML/JS หรือบล็อกสคริปต์ที่รวมอยู่ในเนื้อหาที่จัดรูปแบบซึ่งอาจได้รับการตีความโดยโปรแกรมเรนเดอร์ปลายทาง
• เมตาดาต้าหรือคำอธิบายประกอบ (ความคิดเห็นของไฟล์, เลเยอร์ที่ซ่อนอยู่ใน PDF) ที่ใช้สั่งการระบบการเรียกค้นหรือโมเดล
• พฤติกรรมที่แฝงอยู่ เกิดขึ้นจากการสร้างโค้ดที่ใช้ API ที่เป็นอันตราย (เช่น eval, exec, subprocessหรือการเรียกเครือข่าย/ระบบ) — แม้ว่าเจตนาจะไม่ได้ตั้งใจให้มีเจตนาเป็นอันตรายอย่างชัดเจนก็ตาม
• คำแนะนำแบบฉีดทันที ซึ่งทำให้โมเดลสร้างโค้ดที่รวมคำสั่งที่ซ่อนอยู่หรือตรรกะแบบแบ็คดอร์เนื่องจากผู้โจมตีออกแบบคำเตือนหรือบริบทขึ้นมา

เวกเตอร์การโจมตีเหล่านี้มักเรียกว่า ฉีดด่วน or การฉีดกระตุ้นทางอ้อม เมื่อเป้าหมายคือการเปลี่ยนแปลงพฤติกรรมของโมเดล ปัจจุบันชุมชนด้านความปลอดภัยถือว่าการฉีดแบบทันทีเป็นช่องโหว่หลักใน LLM และ OWASP ได้กำหนดให้เป็นหมวดหมู่ความเสี่ยง LLM อย่างเป็นทางการแล้ว

สิ่งนี้แตกต่างจากมัลแวร์ทั่วไปหรือ XSS อย่างไร?

ความแตกต่างคือ ความหมาย เลเยอร์: การฉีดพรอมต์จะมุ่งเป้าไปที่พฤติกรรมการปฏิบัติตามคำสั่งของโมเดล แทนที่จะเป็นระบบปฏิบัติการโฮสต์หรือเอ็นจิ้นการเรนเดอร์ของเบราว์เซอร์ อย่างไรก็ตาม HTML หรือสคริปต์ที่ซ่อนอยู่ซึ่งสุดท้ายแล้วจะถูกเรียกใช้งานในเว็บเรนเดอร์ยังคงเป็นการโจมตีแบบปฏิบัติการ (คล้าย XSS) จึงต้องป้องกันทั้งเลเยอร์ความหมายและเลเยอร์การดำเนินการ ผู้นำในอุตสาหกรรมและนักวิจัยต่างเรียกการฉีดพรอมต์ว่าเป็น "ความท้าทายด้านความปลอดภัยที่ล้ำหน้า" และยังคงเผยแพร่กลยุทธ์บรรเทาผลกระทบอย่างต่อเนื่อง

เหตุใด LLM จึงสามารถสร้างโค้ดที่ซ่อนอยู่หรือเป็นอันตรายได้

พฤติกรรมจำลอง ข้อมูลการฝึกอบรม และบริบทการสอน

นิติศาสตรมหาบัณฑิต (LLM) ได้รับการฝึกฝนให้สร้างการต่อเนื่องที่สมเหตุสมผลภายใต้บริบทและคำแนะนำ หากบริบทมีสัญญาณบ่งชี้ หรือหากผู้ใช้ขอโค้ดที่ดำเนินการอย่างมีประสิทธิภาพจากแบบจำลอง แบบจำลองสามารถแสดงผลโค้ดที่มีพฤติกรรมที่ละเอียดอ่อนหรือเชิงรุกได้

LLM สร้างโค้ดที่น่าเชื่อถือแต่ไม่ปลอดภัย

หลักสูตร LLM ได้รับการปรับให้เหมาะสมเพื่อความคล่องแคล่วและประโยชน์ใช้สอย ไม่ใช่เพื่อความปลอดภัยเมื่อมีผลข้างเคียงที่เป็นอันตราย พวกเขายินดีสร้างเนื้อหาที่กระชับ rm -rf /path/to/dir or shutil.rmtree() โทรไปเมื่อถูกขอให้ "ทำความสะอาด" — และเนื่องจากคำตอบของพวกเขามักจะใช้ถ้อยคำที่มั่นใจ ผู้ใช้จึงอาจคัดลอกและดำเนินการโดยขาดการตรวจสอบอย่างเพียงพอ ปัญหา "ภาพหลอนที่มั่นใจ" นี้คือสาเหตุที่คำขอที่ดูเหมือนไม่เป็นอันตรายกลับกลายเป็นอันตราย

การทำงานอัตโนมัติของเวิร์กโฟลว์การบดบังข้อมูล

ปัจจุบัน ผู้ก่อภัยคุกคามกำลังทำให้การบดบังโค้ดเป็นระบบอัตโนมัติด้วยการเชื่อมโยงการเรียก LLM เข้าด้วยกัน โดยโมเดลหนึ่งจะสร้างเพย์โหลด อีกโมเดลหนึ่งจะแก้ไขเพย์โหลดเพื่อหลีกเลี่ยงการตรวจจับลายเซ็น และอื่นๆ รายงานภัยคุกคามของอุตสาหกรรมและการวิเคราะห์ของผู้จำหน่ายในปี 2025 ระบุว่า "การบดบังโค้ดด้วย AI" นี้ถือเป็นเทคนิคใหม่ที่กำลังเกิดขึ้น

คุณจะตรวจจับโค้ดที่ซ่อนอยู่ภายในเอาท์พุตของโมเดลได้อย่างไร

รายการตรวจสอบการคัดแยกแบบด่วน

1. สแกนหา Unicode ที่มองไม่เห็น/ผิดปกติ (ตัวเชื่อมความกว้างเป็นศูนย์, ช่องว่างความกว้างเป็นศูนย์, เครื่องหมายลำดับไบต์, โฮโมกลิฟที่ไม่ใช่ ASCII)
2. รันการวิเคราะห์แบบคงที่ / การแยกวิเคราะห์ AST เพื่อระบุการใช้งาน API ที่มีประสิทธิภาพ (eval, exec, subprocess, os.system, เสียงสะท้อนเรียก)
3. ค้นหาเพย์โหลดที่เข้ารหัส (base64, hex blobs, สตริงยาวๆ ซ้ำๆ หรือเนื้อหาที่บีบอัด)
4. ตรวจสอบรูปแบบการบดบัง (การต่อสตริงที่สร้างชื่อ API, เลขคณิตอักขระ, chr() โซ่).
5. ใช้การวิเคราะห์เชิงความหมาย เพื่อยืนยันว่าโค้ดดำเนินการ I/O, เครือข่าย หรือการกลายพันธุ์ของระบบไฟล์จริงหรือไม่

การตรวจจับรูปแบบคงที่ (รวดเร็ว บรรทัดแรก)

• การแยกวิเคราะห์และการตรวจสอบที่คำนึงถึงภาษา แยกวิเคราะห์ผลลัพธ์ที่สร้างขึ้นเป็นบล็อกโค้ดทันที เทียบกับข้อความแบบ Prose เรียกใช้ตัวจัดรูปแบบและ Linters (Black/Prettier, pylint, eslint) กฎ Lint ควรตั้งค่าสถานะการใช้งาน eval, exec, rm -rfการเรียกกระบวนการย่อยแบบดิบหรือท่อเชลล์ที่สร้างคำสั่งแบบไดนามิก
• สแกนเนอร์รูปแบบโทเค็นและสตริง ค้นหาโทเค็นและรูปแบบที่มีความเสี่ยงสูง: sudoเส้นทางสัมบูรณ์เช่น /home/, C:\, rm -rf, shutil.rmtree, subprocess.Popen, บล็อบ base64 แบบอินไลน์, สตริงยาวๆ ที่ไม่สามารถตีความได้ และเชแบงที่สลับบริบทอินเทอร์พรีเตอร์
• การสแกนความลับและการตรวจสอบที่มา ตรวจจับข้อมูลประจำตัวที่ถูกเข้ารหัสแบบฮาร์ดโค้ด URL ที่ชี้ไปยังรีจิสทรีที่ไม่น่าเชื่อถือ หรือโค้ดที่ดึงแพ็คเกจจากแหล่งที่กำหนดเองแบบไดนามิก

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

การตรวจจับความหมายและบริบท (เชิงลึก)

• การวิเคราะห์เจตนา ใช้โมเดลรองหรือกลไกกฎเพื่อจำแนกประเภทของเจตนาของโค้ดที่สร้างขึ้น: มันคือ "อ่าน" "เขียน" "ลบ" "เครือข่าย" "ติดตั้ง" หรือไม่? อะไรก็ตามที่จัดอยู่ในประเภทลบ/เขียนควรทำให้เกิดการยกระดับ
• การวิเคราะห์การไหลของข้อมูล วิเคราะห์โค้ดเพื่อตรวจสอบว่าเส้นทางที่ไม่ได้รับการตรวจสอบหรือเส้นทางที่ผู้ใช้ระบุสามารถเข้าถึง API ที่เป็นอันตรายได้หรือไม่ ตัวอย่างเช่น หากตัวแปรที่ได้มาจากเอาต์พุต LLM หรือไฟล์ระยะไกลถูกนำมาต่อเข้ากับคำสั่งเชลล์ในภายหลัง ให้ตั้งค่าสถานะตัวแปรนั้น
• ความสัมพันธ์ของแหล่งที่มา เก็บบันทึกการสนทนา ข้อความแจ้งเตือนของระบบ และหน้าบริบททั้งหมด หากผลลัพธ์ที่น่าสงสัยเชื่อมโยงกับเอกสารภายนอกหรือการเรียกใช้ปลั๊กอินใดๆ นั่นอาจบ่งชี้ถึงการแทรกข้อความแจ้งเตือนหรือบริบทที่ปนเปื้อน

การตรวจจับแบบไดนามิกและพฤติกรรม (เชื่อถือได้มากที่สุด)

• การดำเนินการแบบแซนด์บ็อกซ์พร้อมการตรวจสอบ ดำเนินการโค้ดที่สร้างขึ้นในสภาพแวดล้อมชั่วคราวที่มีข้อจำกัดอย่างเข้มงวด โดยไม่มีเครือข่าย ไม่มีการเชื่อมต่อโฮสต์ และการกรอง syscall (seccomp) ตรวจสอบกิจกรรมของระบบไฟล์ ความพยายามในการเรียกใช้เครือข่าย การสร้างกระบวนการ และ I/O ที่ผิดปกติ
• การทดสอบนกขมิ้น ก่อนที่จะรันบนข้อมูลจริง ให้รันโค้ดกับไดเร็กทอรีสังเคราะห์ที่มีไฟล์เซนทิเนล จากนั้นตรวจสอบว่ามีการลบหรือเขียนทับหรือไม่
• ฮิวริสติกเชิงพฤติกรรม ค้นหาลูปที่ผ่านไดเร็กทอรีหลัก การดำเนินการซ้ำโดยไม่ตรวจสอบความลึก หรือการเปลี่ยนชื่อรูปแบบที่อาจทำให้ไฟล์เสียหายได้ (เช่น การเขียนชื่อไฟล์เดียวกันซ้ำๆ)
  การวิเคราะห์แบบไดนามิกเป็นวิธีเดียวที่จะตรวจจับเพย์โหลดที่ถูกบดบัง ล่าช้า หรือถูกทริกเกอร์ในระหว่างรันไทม์เท่านั้น

คุณควรลบหรือทำให้โค้ดที่ซ่อนอยู่เป็นกลางอย่างไรก่อนดำเนินการเอาต์พุต LLM

การกำจัดเชิงป้องกันเทียบกับการเปลี่ยนแปลงความหมาย

มีเป้าหมายสองประการเมื่อ "ลบโค้ดที่ซ่อนอยู่":

1. การรักษาสุขอนามัย — ลบเนื้อหาที่ชัดเจนว่าไม่ใช่โค้ดหรือน่าสงสัย (Unicode ที่มองไม่เห็น, อักขระความกว้างศูนย์, เพย์โหลด base64 ที่เพิ่มเข้ามา) การกระทำนี้ไม่ควรเปลี่ยนตรรกะที่ตั้งใจไว้และไม่เป็นอันตราย
2. การวางตัวเป็นกลาง — สำหรับสิ่งใดก็ตามที่ดำเนินการหรือเรียกใช้บริการภายนอก ให้ปิดการใช้งานการเรียกใช้เหล่านั้นหรือกำหนดให้ไม่มีการดำเนินการใดๆ จนกว่าจะได้รับการยืนยัน

ชอบเสมอ การทำให้เป็นกลาง + รีวิว การลบแบบปิดบังมากเกินไป: การลบบางส่วนของโค้ดออกไปโดยพลการอาจทำให้เกิดพฤติกรรมที่ผิดพลาดหรือไม่คาดคิดได้ ควรแทนที่โครงสร้างที่น่าสงสัยด้วยสตับที่บันทึกไว้อย่างชัดเจนซึ่งล้มเหลวอย่างปลอดภัย (สร้างข้อยกเว้นหรือส่งคืนค่าเริ่มต้นที่ปลอดภัย)

ขั้นตอนที่ 1 — ปฏิบัติต่อโค้ดที่สร้างขึ้นเป็นข้อมูลที่ไม่น่าเชื่อถือ

ห้ามรันโค้ดโดยตรงจาก ChatGPT (หรือ LLM ใดๆ) โดยไม่ผ่านขั้นตอนการลบและเสริมความแข็งแกร่ง ขั้นตอนการลบและเสริมความแข็งแกร่งควรได้รับการบังคับใช้ตามนโยบายและดำเนินการโดยอัตโนมัติใน CI/CD

ขั้นตอนที่ 2 — แยกและสร้างโค้ดให้เป็นมาตรฐาน

• ทำให้ข้อความเป็นมาตรฐานและลบอักขระความกว้างเป็นศูนย์: ตัดอักขระต่างๆ เช่น U+200B, U+200C, U+200D, U+FEFF และจุดรหัสความกว้างศูนย์/การจัดรูปแบบอื่นๆ บันทึกสิ่งที่ถูกลบออกเพื่อตรวจสอบ ขั้นตอนนี้จะกำจัดการเข้ารหัส "ที่ซ่อนอยู่" จำนวนมากที่ใช้สำหรับการซ่อนภาพ
• ลบบริบทที่ไม่ใช่โค้ดทั้งหมด: ลบคำบรรยาย ความคิดเห็นที่ซ่อนอยู่ และ wrapper HTML/Markdown ใดๆ แปลงโค้ดเป็นรูปแบบมาตรฐานโดยใช้ตัวจัดรูปแบบภาษา (Black, Prettier) เพื่อให้ช่องว่างหรืออักขระควบคุมที่ถูกบดบังได้รับการทำให้เป็นมาตรฐาน
• ปฏิเสธหรือกักกันโค้ดด้วยโครงสร้างเหล่านี้: พลวัต evalการเรียกกระบวนการย่อยแบบดิบ (os.system, subprocess.Popen), blobs base64 แบบอินไลน์ที่ถอดรหัสเป็นการดำเนินการหรือฝังไว้ #! คำสั่งที่พยายามเปลี่ยนบริบทของล่าม ทำให้ข้อความเป็นมาตรฐานและลบอักขระความกว้างเป็นศูนย์
  ตัดอักขระต่างๆ เช่น U+200B, U+200C, U+200D, U+FEFF และจุดรหัสความกว้างศูนย์/การจัดรูปแบบอื่นๆ บันทึกสิ่งที่ถูกลบออกเพื่อตรวจสอบ ขั้นตอนนี้จะกำจัดการเข้ารหัส "ที่ซ่อนอยู่" จำนวนมากที่ใช้สำหรับการซ่อนภาพ

ขั้นตอนที่ 3 — แยกวิเคราะห์เป็น AST และแทนที่โหนดที่มีความเสี่ยง

เมื่อวิเคราะห์โค้ดเป็น AST แล้ว ให้ค้นหาโหนดที่เรียกใช้การดำเนินการแบบไดนามิก (เช่น exec) หรือสร้างชื่อฟังก์ชันด้วยโปรแกรม แทนที่ด้วยสตั๊บที่ปลอดภัยซึ่งสร้างข้อยกเว้นควบคุมที่ระบุว่า "พฤติกรรมไดนามิกที่ไม่ปลอดภัยถูกบล็อก" สร้างสำเนาที่ผ่านการตรวจสอบแล้วของซอร์สโค้ดที่ได้รับการสนับสนุนโดย AST เพื่อตรวจสอบ เรียกใช้การตรวจสอบรูปแบบความปลอดภัย (กฎ semgrep ที่กำหนดเองสำหรับสภาพแวดล้อมของคุณ) ทำเครื่องหมายและทำให้เป็นกลางเมื่อพบรายการที่ตรงกัน

ขั้นตอนที่ 4 — การทำให้แข็งแกร่งและการเขียนใหม่แบบคงที่

• การเขียนใหม่อัตโนมัติ: รหัสผ่านผ่านโปรแกรมฆ่าเชื้ออัตโนมัติที่แทนที่การโทรที่เป็นอันตรายด้วยตัวห่อที่ปลอดภัย เช่น แทนที่ os.system() / subprocess โดยมีผู้ดำเนินการแซนด์บ็อกซ์ที่ได้รับอนุมัติซึ่งบังคับใช้การหมดเวลาและการบล็อกเครือข่าย
• การกำหนดความสามารถ: แก้ไขหรือลบคีย์ API โทเค็น หรือการเรียกไปยังจุดสิ้นสุดที่มีสิทธิ์พิเศษ แทนที่ด้วยอะแดปเตอร์จำลองสำหรับการทดสอบในเครื่อง ป้องกันการใส่รหัสลับหรือ URL โดยไม่ได้ตั้งใจ
• การเขียนซ้ำการอ้างอิง: บล็อกไดนามิก pip / npm การติดตั้งที่สร้างโดยโค้ด จำเป็นต้องประกาศและอนุมัติการอ้างอิงผ่านรีจิสทรีของคุณ

ขั้นตอนที่ 5 — วิ่งในกระบะทรายที่ก้าวร้าว

• คอนเทนเนอร์ชั่วคราว / microVMs: รันโค้ดในคอนเทนเนอร์/VM ที่ไม่มีเครือข่าย ไม่มีสิทธิ์เข้าถึงข้อมูลประจำตัวของโฮสต์ และสิทธิ์เข้าถึงระบบไฟล์ที่จำกัด เทคโนโลยีอย่าง gVisor, Firecracker หรือบริการรันโค้ดชั่วคราวเฉพาะทางก็เหมาะสม หากโค้ดต้องเข้าถึง I/O ให้ใช้พร็อกซีที่บังคับใช้นโยบาย
• ตัวกรองการเรียกระบบและ seccomp: จำกัดการเรียกใช้งาน syscalls ที่อนุญาต การเขียนไฟล์นอกไดเรกทอรีชั่วคราวควรถูกบล็อก
• ขีดจำกัดทรัพยากร/เวลา: ตั้งค่าขีดจำกัด CPU/หน่วยความจำ/เวลา เพื่อให้แม้แต่ระเบิดลอจิกก็ไม่สามารถทำงานได้อย่างไม่มีกำหนด

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

คุณควรมีเครื่องมือและกฎอัตโนมัติใดบ้างในขั้นตอนการผลิตของคุณ?

ส่วนประกอบเครื่องมือที่แนะนำ

• โมดูลสุขาภิบาล Unicode (ไลบรารีแบบกำหนดเองหรือที่มีอยู่แล้ว) จะต้องบันทึกอักขระที่เป็นมาตรฐาน
• ตัววิเคราะห์ Parser + AST สำหรับแต่ละภาษาเป้าหมาย (Python ast, typed-ast, ตัววิเคราะห์ JavaScript, ตัววิเคราะห์ Java)
• เครื่องวิเคราะห์แบบคงที่ / SAST: Bandit (Python), Semgrep (หลายภาษา, ปรับแต่งได้), ESLint พร้อมปลั๊กอินด้านความปลอดภัย
• ฮิวริสติกของเอนโทรปีและตัวถอดรหัส:ตรวจจับ base64/hex/gzip และกำหนดเส้นทางไปยังการตรวจสอบ
• รันไทม์แซนด์บ็อกซ์:คอนเทนเนอร์ขั้นต่ำที่มีโปรไฟล์ seccomp/AppArmor ที่เข้มงวดหรืออินเทอร์พรีเตอร์ระดับภาษาที่มี syscalls ที่ปิดใช้งาน
• ผู้บังคับใช้นโยบาย:ส่วนประกอบที่ตัดสินใจเกี่ยวกับโมดูลที่อนุญาต จุดสิ้นสุดที่อนุญาต และตัวห่อ API ที่ปลอดภัย
• ตรวจสอบบัญชี:บันทึกที่ไม่เปลี่ยนแปลงที่บันทึกเอาท์พุตต้นฉบับ เอาท์พุตที่ผ่านการฆ่าเชื้อ ความแตกต่าง และการตัดสินใจ

ตัวอย่างรูปแบบ semgrep (เชิงแนวคิด)

ใช้กฎเกณฑ์ที่สั้นและอนุรักษ์นิยมเพื่อเตือนการใช้งานฟังก์ชันที่เป็นอันตราย ตัวอย่างเช่น:

• ธง eval, exec, Function ตัวสร้าง (JS) การนำเข้าแบบไดนามิก หรือชื่อ API ที่สร้างด้วยสตริง
• ตั้งค่าสถานะการโทรผ่านเครือข่ายนอกรายการอนุญาต (เช่น requests.get ไปยังโฮสต์ที่ไม่รู้จัก)
• แฟล็กเขียนไปยังเส้นทางที่ละเอียดอ่อน (/etc, โฟลเดอร์ระบบ) หรือการสร้างกระบวนการ

(เก็บสิ่งเหล่านี้ไว้เป็นรายการกำหนดค่าต่อองค์กรและปรับให้เข้มงวดขึ้นในภายหลัง)

ตัวอย่างการฆ่าเชื้อในทางปฏิบัติ (ตัวอย่างที่ปลอดภัย) คืออะไร

ด้านล่างนี้เป็นตัวอย่างการป้องกันที่ไม่เป็นอันตรายซึ่งคุณสามารถนำไปปรับใช้ได้ การฆ่าเชื้อและการตรวจจับ ตัวอย่าง — ไม่ใช่คำแนะนำในการใช้ประโยชน์

ตัวอย่าง: ลบอักขระความกว้างเป็นศูนย์ (Python, ป้องกัน)

import re
ZERO_WIDTH_RE = re.compile(r'')
def strip_zero_width(s: str) -> str:
    cleaned = ZERO_WIDTH_RE.sub('', s)
    return cleaned

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

ตัวอย่าง: แยกวิเคราะห์และตรวจสอบ AST (Python, แนวคิด)

import ast

def has_dynamic_exec(source: str) -> bool:
    tree = ast.parse(source)
    for node in ast.walk(tree):
        if isinstance(node, ast.Call):
            if getattr(node.func, 'id', '') in ('eval', 'exec',):
                return True
        if isinstance(node, ast.Attribute):
            if getattr(node, 'attr', '') in ('popen', 'system'):
                return True
    return False

If has_dynamic_exec ส่งคืนค่า True อย่ารันโค้ด แต่ให้แทนที่โหนดไดนามิกด้วยสตับที่ปลอดภัยและต้องการการตรวจสอบ

หมายเหตุ: ตัวอย่างเหล่านี้มีจุดประสงค์เพื่อป้องกันตัวเอง อย่าลบการบันทึก การตรวจสอบ หรือการตรวจสอบโดยมนุษย์ออกจากไปป์ไลน์ของคุณ

ความคิดปิดท้าย: ปฏิบัติต่อผลลัพธ์ LLM เหมือนกับโค้ดที่ไม่น่าเชื่อถือเสมอ

LM เป็นเครื่องมือเพิ่มประสิทธิภาพการทำงานอันทรงพลัง สามารถสร้างโค้ดที่สวยงาม เร่งกระบวนการร่าง และทำให้งานประจำเป็นแบบอัตโนมัติ แต่ในจุดที่ LM ตอบสนองความต้องการด้านการดำเนินการ กฎเกณฑ์ด้านความปลอดภัยจะเปลี่ยนไป: ผลลัพธ์ของโมเดลจะต้องได้รับการปฏิบัติเหมือนเป็นสิ่งประดิษฐ์ที่ไม่น่าเชื่อถือการผสมผสานระหว่างการฉีดยาอย่างรวดเร็ว การวิจัยทางลับ และการเปิดเผยช่องโหว่ในโลกแห่งความเป็นจริงในช่วง 18–30 เดือนที่ผ่านมา ชี้ให้เห็นชัดเจนว่า พื้นผิวความเสี่ยงได้ขยายตัวมากขึ้นและจะพัฒนาต่อไป

การป้องกันเชิงปฏิบัติที่ผสมผสานการแยกวิเคราะห์ การวิเคราะห์แบบคงที่ การทดสอบแบบไดนามิกแบบแซนด์บ็อกซ์ การกำกับดูแล และการทำ Red Teaming อย่างต่อเนื่อง จะสามารถหยุดยั้งการโจมตีส่วนใหญ่ได้ แต่ทีมงานยังต้องลงทุนในการควบคุมระดับองค์กรด้วย เช่น สิทธิ์ขั้นต่ำ แหล่งที่มา และวัฒนธรรมที่ถือว่าผลลัพธ์ LLM จำเป็นต้องมีการตรวจสอบความถูกต้อง อุตสาหกรรมกำลังสร้างเครื่องมือและกรอบการทำงานเพื่อทำให้รูปแบบเหล่านี้ง่ายขึ้น ในขณะเดียวกัน การนำรายการตรวจสอบข้างต้นมาใช้จะช่วยลดโอกาสที่เพย์โหลดที่ซ่อนอยู่จะหลุดออกไป

นักพัฒนาสามารถเข้าถึง LLM API ล่าสุดได้ เช่น คล็อด ซอนเน็ต 4.5 API และ Gemini 3 Pro พรีวิว ฯลฯ ผ่าน CometAPI รุ่นใหม่ล่าสุด ได้รับการอัปเดตอยู่เสมอจากเว็บไซต์อย่างเป็นทางการ เริ่มต้นด้วยการสำรวจความสามารถของโมเดลใน สนามเด็กเล่น และปรึกษา คู่มือ API สำหรับคำแนะนำโดยละเอียด ก่อนเข้าใช้งาน โปรดตรวจสอบให้แน่ใจว่าคุณได้เข้าสู่ระบบ CometAPI และได้รับรหัส API แล้ว โคเมทเอพีไอ เสนอราคาที่ต่ำกว่าราคาอย่างเป็นทางการมากเพื่อช่วยคุณบูรณาการ

พร้อมไปหรือยัง?→ ลงทะเบียน CometAPI วันนี้ !

หากคุณต้องการทราบเคล็ดลับ คำแนะนำ และข่าวสารเกี่ยวกับ AI เพิ่มเติม โปรดติดตามเราที่ VK, X และ ไม่ลงรอยกัน!