SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor · อัปเดตเมื่อ 2026-10-23

Prompt injection โจมตี coding agent จากจุดใดบ้าง

ทำความเข้าใจจุดที่ผู้โจมตีแทรกข้อความใน coding agent บนเซิร์ฟเวอร์ ตั้งแต่ไฟล์และ pull request ถึง tool call พร้อมจัดลำดับการป้องกันที่ลดความเสียหายได้จริง

Prompt injection ต่อ coding agent คืออะไร

Prompt injection ต่อ coding agent อธิบายได้ง่าย ๆ ว่า ข้อความที่ agent อ่านจะถูกปฏิบัติเสมือนเป็นคำสั่งที่ agent ต้องทำตาม agent อาจเปิดไฟล์ ความคิดเห็นใน pull request เว็บเพจ หรือผลลัพธ์จาก tool call ข้อมูลทั้งหมดนี้จะมาถึงในรูปแบบข้อความเดียวกับคำขอของคุณ หากผู้โจมตีควบคุมข้อความส่วนใดส่วนหนึ่งได้ ผู้โจมตีก็กำลังเขียนข้อความลงใน session ของคุณ

ผลิตภัณฑ์ agent ในปัจจุบันทุกตัวมีคุณสมบัตินี้ model จะได้รับลำดับ token ชุดเดียว คำขอของคุณ system prompt เนื้อหาในไฟล์ และผลลัพธ์จาก tool จะถูกรวมเข้าด้วยกัน จากนั้น model จะคาดการณ์ว่าข้อความถัดไปควรเป็นอะไร รูปแบบนี้ไม่มี privilege bit กำกับ token แต่ละรายการ และไม่มีข้อมูลใดระบุว่าส่วนใดได้รับอนุญาตจากคุณ หรือส่วนใดมาจากไฟล์ README ของบุคคลอื่น

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

เหตุใดโมเดลจึงไม่สามารถแยกเนื้อหาออกจากคำสั่งได้

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

โครงการ OWASP GenAI ติดตามปัญหานี้ในชื่อ LLM01:2026 Prompt Injection ซึ่งเป็นรายการแรกใน 2026 Top 10 สำหรับแอปพลิเคชัน LLM โดยแบ่งออกเป็นสองประเภท: Direct injection คืออินพุตที่ส่งตรงไปยังโมเดลโดยผู้ใช้หรือผู้โจมตีที่มีสิทธิ์ของผู้ใช้เพื่อเปลี่ยนพฤติกรรมของโมเดล ส่วน Indirect injection คือเนื้อหาจากภายนอก เช่น เว็บไซต์หรือไฟล์ ที่เข้ามาเปลี่ยนพฤติกรรมเมื่อโมเดลประมวลผลเนื้อหานั้น Indirect injection เป็นประเด็นสำคัญบนเซิร์ฟเวอร์ เนื่องจากเอเจนต์อ่านข้อความจำนวนมากกว่าที่คุณพิมพ์เองหลายเท่า

การศึกษาเชิงระบบครั้งแรกคือผลงานของ Greshake และคณะ ในหัวข้อ Not what you've signed up for (2023) ข้อสรุปของพวกเขาคือประโยคที่ควรจดจำไว้ว่า: เมื่อแอปพลิเคชันป้อนข้อความที่ดึงมาเข้าสู่โมเดลที่สามารถเรียกใช้เครื่องมือต่างๆ ได้ การประมวลผลข้อความนั้นมีความเสี่ยงใกล้เคียงกับการรันโค้ดโดยพลการ (arbitrary code execution)

เงื่อนไขที่ทำให้การอ่านกลายเป็นการถูกเจาะระบบ

การอ่านข้อความที่เป็นอันตรายไม่ก่อให้เกิดความเสียหายด้วยตัวมันเอง ความเสียหายต้องมีช่องทางออกจากเครื่อง

Simon Willison เรียกการผสมผสานนี้ว่า สามประสานร้ายแรง ในเดือน June 2025 เอเจนต์ที่มีข้อมูลส่วนตัว เข้าถึงเนื้อหาที่ไม่น่าเชื่อถือ และสามารถส่งข้อมูลออกไปได้ อาจถูกชักจูงให้ส่งข้อมูลส่วนตัวออกผ่านช่องทางดังกล่าว

coding agent บน VPS ของคุณมีเงื่อนไขเหล่านี้ครบตั้งแต่เริ่มต้น ข้อมูลส่วนตัวคือ source code, ไฟล์ .env, SSH keys และ shell history ของคุณ เนื้อหาที่ไม่น่าเชื่อถือคือ repository, page และผลลัพธ์จาก tool ทุกอย่างที่เอเจนต์อ่าน ช่องทางออกคือ git push, curl, npm publish, เนื้อหา pull request หรือลิงก์ที่แสดงใน terminal ซึ่งคุณคลิก

คุณไม่สามารถนำเงื่อนไขข้อที่สองออกได้ เพราะการอ่านข้อความที่ไม่น่าเชื่อถือคือหน้าที่ที่คุณมอบหมายให้เอเจนต์ ดังนั้นแนวทางป้องกันที่ใช้ได้จริงทั้งหมดจึงต้องจัดการกับอีก 2 เงื่อนไข

เมื่อข้อความที่ไม่น่าเชื่อถือไปถึง coding agent บนเซิร์ฟเวอร์

Repository ที่ agent กำลังทำงานอยู่

ทุกไฟล์ใน checkout คือ input ทั้งหมด ไม่ว่าจะเป็น comment ใน source code, README.md, changelog, test fixture, code ที่ vendor มา หรือไฟล์คำสั่งของ agent เอง ได้แก่ CLAUDE.md, AGENTS.md และไฟล์ที่เทียบเท่ากัน เมื่อสั่งให้ agent ทำความเข้าใจ codebase agent จะอ่านไฟล์เหล่านี้ เพราะนั่นคือสิ่งที่คุณสั่งให้ทำ

สิ่งที่ผู้โจมตีได้คือช่องทางเข้าถึงทุกคนที่ clone repository แล้วชี้ agent ไปยัง repository นั้น ไฟล์คำสั่งเป็นช่องทางที่ตรงที่สุด เพราะไฟล์เหล่านี้มีไว้ให้อ่านในฐานะคำสั่ง pull request ที่เพิ่มบรรทัดที่เป็นประโยชน์ 4 บรรทัดลงใน CLAUDE.md และเพิ่มอีก 1 บรรทัดเพื่อ redirect agent อาจเป็นการเปลี่ยนแปลงที่ผู้ตรวจสอบซึ่งเป็นมนุษย์อ่านผ่านไปอย่างรวดเร็ว

Issues, pull requests และ comment ในการ code review

ทุกสิ่งที่บุคคลภายนอกพิมพ์ลงใน tracker ได้ จะไปถึง agent ทันทีที่คุณสั่งให้ agent คัดกรอง ใน May 2025, Invariant Labs เผยแพร่ ข้อค้นพบเกี่ยวกับ GitHub MCP ที่มีลักษณะเช่นนี้พอดี agent ของ developer เข้าถึง repository สาธารณะ 1 แห่งและ repository ส่วนตัวหลายแห่ง ผู้โจมตีเปิด issue ใน repository สาธารณะ เมื่อ developer สั่งให้ agent ตรวจสอบ issue ที่ยังเปิดอยู่ agent อ่านเนื้อหาจาก repository ส่วนตัว แล้วเขียนเนื้อหานั้นลงใน pull request ฝั่งสาธารณะ

รายงานดังกล่าวอธิบายปัญหาด้านสถาปัตยกรรม ไม่ใช่ข้อบกพร่องของ code ใน MCP server agent ถือ access token ที่มีสิทธิ์กว้าง อ่านข้อมูลจาก inbox สาธารณะ และมีสิทธิ์เขียน ไม่มีการตั้งค่าผิดในความหมายทั่วไป นี่จึงเป็นปัญหาที่ต้องแก้ด้วยการจำกัดขอบเขตสิทธิ์ ไม่ใช่การแก้ patch

Web page ที่ agent fetch

Documentation, คำตอบใน forum, หน้าเว็บของ vendor และผลการค้นหา สิ่งใดก็ตามอาจมีข้อความที่เขียนถึง agent แทนที่จะเขียนถึงคุณ HTML ที่แปลงเป็น text เปิดพื้นที่ให้ผู้โจมตีเพิ่มขึ้น เพราะเนื้อหาที่ browser ไม่เคยแสดงก็ยังไปถึง model ได้

ผู้โจมตีได้การควบคุมในช่วงที่มีการเฝ้าดู agent น้อยที่สุด ไม่มีใครอ่านข้อความทั้งหมดของ page ที่ agent fetch ขณะค้นข้อมูล

MCP tool output

MCP (model context protocol) เป็นวิธีทั่วไปที่ agent ใช้เชื่อมต่อกับ external tool ผลลัพธ์จะกลับมาเป็น text และเข้าสู่ context window โดยตรง ในส่วนนี้มี attack surface 2 จุด ไม่ใช่ 1 จุด จุดแรกคือข้อมูลที่ tool ส่งกลับมา ซึ่งเห็นได้ชัด อีกจุดคือชื่อและคำอธิบายของ tool เอง ซึ่ง model อ่านเพื่อพิจารณาว่าจะเรียกใช้ tool เมื่อใด และ server ที่คุณไม่ได้ควบคุมอาจเปลี่ยนแปลงสิ่งใดสิ่งหนึ่งระหว่างการเรียกแต่ละครั้งได้

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

CI log, build output และ dependency metadata

npm install พิมพ์ข้อความจาก package ที่คุณไม่ได้เขียน test failure พิมพ์ assertion message จาก library ส่วน log ของ continuous integration (CI) job มี output จาก third party หลายพันบรรทัด เมื่อสั่งให้ agent แก้ build ที่ล้มเหลว agent จะอ่านข้อมูลทั้งหมด

ในกรณีนี้ผู้โจมตีได้เข้าถึง build machine ซึ่งโดยทั่วไปมี deploy credential และ registry token อีกทั้งมักได้รับความสนใจน้อยกว่า laptop】【。

สิ่งที่ผู้โจมตีได้รับจริง

ควรวางแผนรับมือผลลัพธ์ 4 รูปแบบ

การขโมยข้อมูลรับรอง สิ่งใดก็ตามที่ process ของ agent อ่านได้ล้วนอยู่ในขอบเขตความเสี่ยง ได้แก่ environment variables, ~/.aws/credentials, ~/.ssh, token ของ gh และไฟล์ config ของ Docker การส่งข้อมูลเหล่านี้ออกไปไม่จำเป็นต้องใช้ curl การ commit ไปยัง branch, คำอธิบายใน pull request, package ที่เผยแพร่ไปยัง registry หรือ DNS lookup สำหรับชื่อที่ผู้โจมตีควบคุม ล้วนทำให้ข้อมูลออกจากเครื่องได้

การเปลี่ยนแปลงโค้ดที่คุณอนุมัติ การเขียนโค้ดคือหน้าที่ของ agent ดังนั้นการทำให้ agent เขียนบรรทัดที่ผิดอย่างแนบเนียนจึงเป็นผลลัพธ์ที่ทำได้ง่ายที่สุด เช่น การเพิ่ม dependency หรือการเพิ่ม logging call ที่นำ token ไปไว้ใน log ซึ่งคุณส่งต่อไปยังที่อื่น

การคงอยู่ในระบบ ไฟล์ที่ถูกเขียนเพียงครั้งเดียวยังคงทำงานได้โดยไม่ต้องมี model เกี่ยวข้อง เช่น hook ใน .git/hooks, สคริปต์ postinstall ใน package.json, บรรทัดที่เพิ่มต่อท้ายไฟล์เริ่มต้นของ shell หรือบรรทัดเพิ่มเติมใน CLAUDE.md คำสั่งถัดไปจะเรียกใช้งานสิ่งนั้น

การเคลื่อนย้ายภายในเครือข่าย agent จะทำงานบนเครื่องที่คุณนำไปติดตั้ง หากเครื่องนั้นเชื่อมต่อไปยัง database ผ่าน loopback, บริการผู้ดูแลระบบภายใน, metadata service ของ cloud provider หรือ host อื่นใน private network สิ่งใดก็ตามที่ควบคุม agent ก็จะเข้าถึงปลายทางเหล่านั้นได้เช่นกัน

โหมดการอนุมัติอัตโนมัติจะตัดขั้นตอนการตรวจสอบขั้นสุดท้ายออก

ในโหมด Manual ซึ่งมีค่าคอนฟิกคือ default ตัว Claude Code จะสอบถามก่อนที่จะรันคำสั่งหรือแก้ไขไฟล์ทุกครั้ง ข้อความแจ้งเตือนนั้นคือการตรวจสอบโดยมนุษย์ที่คั่นกลางระหว่างอินเทอร์เฟซทั้งหมดกับการกระทำจริง โหมดที่ตัดข้อความแจ้งเตือนออกไปจึงเป็นการตัดขั้นตอนการตรวจสอบนี้ออกด้วย นับตั้งแต่ Claude Code v2.1.283 เป็นต้นมา โหมด Manual ไม่ใช่จุดเริ่มต้นของเซสชันอีกต่อไป โดยเซสชันในเทอร์มินัลแบบโต้ตอบและ VS Code จะเริ่มต้นในโหมดอัตโนมัติ เว้นแต่จะมีการตั้งค่าอื่นกำหนดไว้ (ตรวจสอบเมื่อเดือนตุลาคม 2026)

เอกสารระบุไว้อย่างชัดเจนเกี่ยวกับ bypassPermissions ว่าให้ใช้เฉพาะในสภาพแวดล้อมที่แยกส่วน เช่น คอนเทนเนอร์หรือ VM ซึ่ง Claude Code ไม่สามารถสร้างความเสียหายได้ โหมดอัตโนมัติมีความยืดหยุ่นกว่า โดยจะมีโมเดลจำแนกประเภทแยกต่างหากคอยตรวจสอบการกระทำก่อนที่จะรัน และจะบล็อกทุกสิ่งที่เกินขอบเขตจากคำขอของคุณ การกระทำที่มุ่งเป้าไปยังโครงสร้างพื้นฐานที่ไม่รู้จัก หรือสิ่งที่ดูเหมือนจะถูกขับเคลื่อนด้วยเนื้อหาที่เป็นอันตรายที่ Claude อ่านเจอ การตรวจสอบเหล่านี้ช่วยคัดกรองปัญหาได้มาก อย่างไรก็ตาม สิ่งเหล่านี้ยังคงเป็นการตัดสินโดยโมเดลต่อผลลัพธ์ของโมเดล ดังนั้นให้ถือว่าเป็นตัวกรองไม่ใช่ขอบเขตความปลอดภัยที่สมบูรณ์

หากต้องการคงข้อความแจ้งเตือนไว้ ให้ตั้งค่า permissions.defaultMode เป็น "default" (หรือนามแฝงคือ "manual") ใน ~/.claude/settings.json หรือในไฟล์ .claude/settings.json ของโปรเจกต์ ผู้ดูแลระบบสามารถลบอีกสองโหมดออกไปได้ทั้งหมด โดยตั้งค่า permissions.disableBypassPermissionsMode หรือ permissions.disableAutoMode เป็น "disable" ในไฟล์การตั้งค่า และนำไฟล์นั้นไปไว้ในการตั้งค่าที่มีการจัดการ (managed settings) เพื่อไม่ให้โปรเจกต์ที่ถูกเช็คเอาต์มาสามารถเขียนทับได้ คู่มือของเราในหัวข้อ โหมดอัตโนมัติและกฎการอนุญาตของ Claude Code ครอบคลุมรายละเอียดว่าแต่ละกฎมีผลบังคับใช้ที่ใดบ้าง

การป้องกัน จัดลำดับตามสิ่งที่ได้รับ

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

  1. เครื่องที่คุณสามารถทำลายและสร้างใหม่ได้ เพื่อให้ความเสียหายจากการถูกบุกรุกใช้เวลาแก้ไขเพียงหนึ่งชั่วโมงแทนที่จะกลายเป็นเหตุการณ์ใหญ่
  2. ข้อมูลรับรอง (credentials) ที่แยกจากของคุณเอง จำกัดขอบเขตไว้ที่ repository เดียว และมีอายุการใช้งานสั้น
  3. ไม่เก็บความลับที่มีอายุการใช้งานยาวนานไว้ในสภาพแวดล้อมที่คำสั่งของเอเจนต์สืบทอดไปใช้
  4. การบังคับใช้ระดับระบบปฏิบัติการ (OS) ในการควบคุมการออกสู่เครือข่าย (egress) และการเข้าถึงไฟล์ ซึ่งมีผลกับทุกกระบวนการที่เอเจนต์เริ่มทำงาน
  5. การคงการแจ้งเตือนเพื่อขออนุมัติไว้สำหรับการเขียนข้อมูลและการเรียกใช้เครือข่าย
  6. การใช้ Hooks เป็นกลไกป้องกันเชิงกำหนด (deterministic backstop) สำหรับการกระทำเฉพาะที่คุณระบุได้
  7. การอ่าน diff ก่อนที่คุณจะทำการ merge

ลำดับมีความสำคัญ ข้อ 1 ถึง 4 ยังคงมีผลแม้ในขณะที่โมเดลอยู่ภายใต้การควบคุมของผู้โจมตีโดยสมบูรณ์ ส่วนข้อ 5 ถึง 7 ขึ้นอยู่กับการที่มนุษย์คอยตรวจสอบ ซึ่งเป็นสิ่งที่มักจะละเลยไปเมื่อเอเจนต์ทำงานเป็นเวลานาน

วางเอเจนต์ไว้บนเครื่องที่คุณสามารถทิ้งได้

VPS ที่เก็บโค้ดที่ checkout มาและมีโทเค็นที่จำกัดขอบเขตไว้เพียงหนึ่งรายการ ถือเป็นเป้าหมายที่เล็กกว่าแล็ปท็อปที่มีกุญแจสำคัญของคุณเก็บอยู่มาก ให้รันเอเจนต์ในฐานะผู้ใช้ที่ไม่มีสิทธิ์ (unprivileged user) ของตนเอง ไม่ใช่ในฐานะบัญชีล็อกอินของคุณและไม่ใช่ในฐานะ root คู่มือของเราเรื่อง การใช้ VM แบบใช้แล้วทิ้งสำหรับเอเจนต์เขียนโค้ด และ การใช้ผู้ใช้ที่มีสิทธิ์น้อยที่สุดบน VPS ครอบคลุมการตั้งค่านี้ และ การรัน Claude Code อย่างปลอดภัยบน VPS ครอบคลุมการใช้งานในแต่ละวัน

นำความลับออกจากสภาพแวดล้อม

ตัวแปรสภาพแวดล้อม (environment variable) สามารถอ่านได้โดยทุกกระบวนการลูก ซึ่งหมายถึงทุกคำสั่งที่เอเจนต์รัน Sandbox ของ Claude Code สามารถยกเลิกการตั้งค่าตัวแปรที่ระบุไว้ก่อนแต่ละคำสั่งใน sandbox ได้ บน Linux ตัว sandbox จำเป็นต้องมีสองแพ็กเกจนี้ก่อน:

sudo apt-get install bubblewrap socat

บน Ubuntu 24.04 ขึ้นไป นโยบาย AppArmor เริ่มต้นจะหยุดไม่ให้ bubblewrap สร้าง user namespaces ที่จำเป็น หาก sysctl kernel.apparmor_restrict_unprivileged_userns ส่งค่ากลับเป็น 1 ให้เพิ่มโปรไฟล์ AppArmor แบบสั้นสำหรับ bwrap ตามที่เอกสารประกอบการทำ sandboxing ของ Claude Code ระบุไว้ จากนั้นจึงโหลด AppArmor ใหม่

จากนั้นใน ~/.claude/settings.json:

{
  "sandbox": {
    "enabled": true,
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"],
      "strictAllowlist": true
    },
    "credentials": {
      "envVars": [
        { "name": "GITHUB_TOKEN", "mode": "deny" },
        { "name": "NPM_TOKEN", "mode": "deny" }
      ]
    }
  }
}

รายการ deny จะยกเลิกการตั้งค่าตัวแปรนั้นก่อนที่แต่ละคำสั่งใน sandbox จะทำงาน และ allowedDomains จะระบุรายการโฮสต์ที่คำสั่งใน sandbox สามารถเข้าถึงได้ หากไม่มี strictAllowlist โหมดการอนุญาตของคุณจะเป็นตัวตัดสินว่าจะเกิดอะไรขึ้นกับโฮสต์ที่อยู่นอกรายการนั้น: โหมด Manual จะแจ้งเตือนคุณ และโหมด auto จะอนุญาตให้ตัวจำแนกประเภท (classifier) เปิดโฮสต์เพิ่มเติมสำหรับคำสั่งเดียว ส่วน strictAllowlist จะปฏิเสธทุกโฮสต์ที่ไม่อยู่ในรายการ ซึ่งต้องใช้ Claude Code v2.1.219 ขึ้นไปและมีผลเฉพาะจากการตั้งค่าของผู้ใช้หรือการตั้งค่าที่มีการจัดการเท่านั้น ดังนั้น repository จึงไม่สามารถปิดการใช้งานได้ (ตรวจสอบเมื่อตุลาคม 2026) บล็อก credentials ต้องใช้ Claude Code v2.1.187 ขึ้นไป ตรวจสอบเมื่อสิงหาคม 2026 รัน /sandbox ในเซสชันเพื่อดูว่าเลเยอร์ใดทำงานอยู่และมี dependency ใดที่ขาดหายไป การตัดสินใจว่าความลับใดจำเป็นต้องมีอยู่บนเครื่องนั้นหรือไม่ถือเป็นงานส่วนใหญ่ และ การเก็บความลับให้พ้นจากมือของ AI agent จะช่วยอธิบายขั้นตอนในส่วนนี้

ตัดการเชื่อมต่อเครือข่ายขาออกที่ระดับระบบปฏิบัติการ

กฎไฟร์วอลล์ไม่สนใจสิ่งที่โมเดลตัดสินใจ ให้รันเอเจนต์ในฐานะผู้ใช้ agent โดยเฉพาะ จากนั้นจึงดรอปแพ็กเก็ตที่ผู้ใช้นั้นส่งออกไป:

table inet agentcage {
  chain output {
    type filter hook output priority filter; policy accept;
    meta skuid "agent" ct state established,related accept
    meta skuid "agent" oif lo accept
    meta skuid "agent" counter drop
  }
}

นั่นทำให้ผู้ใช้ agent สามารถใช้งานได้เฉพาะ loopback เท่านั้น ดังนั้นทราฟฟิกของมันจึงต้องผ่านพร็อกซีที่คุณรันบนเครื่องเดียวกัน และพร็อกซีนั้นจะเป็นตัวเก็บรายการอนุญาต (allowlist) ของชื่อโฮสต์ เมื่อตั้งค่า https_proxy ให้ชี้ไปที่พร็อกซีนั้น ไคลเอนต์จะส่งคำขอ CONNECT และพร็อกซีจะเป็นผู้ดำเนินการค้นหาชื่อโฮสต์ ดังนั้นเอเจนต์จึงไม่จำเป็นต้องมีการเข้าถึง DNS (domain name system) ขาออกของตนเอง ตรวจสอบการทำงานของคุณด้วย sudo nft list ruleset และสังเกตตัวนับบนกฎการดรอปที่เพิ่มขึ้นในขณะที่เอเจนต์พยายามเข้าถึงสิ่งใหม่

เปิดเซสชัน SSH สำรองไว้ในขณะที่คุณใช้การเปลี่ยนแปลงไฟร์วอลล์ ตรวจสอบด้วยว่า container runtime ของคุณทำอย่างไรกับกฎเหล่านี้ Docker จะเขียน chain ของตัวเอง และ พอร์ต Docker ที่เผยแพร่ออกไปจะข้าม ufw อธิบายถึงปัญหาที่อาจเกิดขึ้นโดยไม่คาดคิด

Hooks: การตรวจสอบที่โมเดลไม่สามารถหาทางเลี่ยงได้

กฎการอนุญาตและ hooks ถูกบังคับใช้โดย Claude Code ไม่ใช่โดยโมเดล เอกสารระบุไว้อย่างชัดเจนว่าคำแนะนำใน prompt ของคุณหรือ CLAUDE.md จะกำหนดสิ่งที่ Claude พยายามทำ แต่สิ่งเหล่านี้ไม่เปลี่ยนสิ่งที่ Claude Code อนุญาต ความแตกต่างนั้นคือคุณค่าทั้งหมด บรรทัดใน CLAUDE.md ที่เขียนว่า "never run curl" เป็นเพียงข้อเสนอแนะที่ย่อหน้าที่ถูกแทรกเข้ามาสามารถโต้แย้งได้ แต่ hook คือกระบวนการที่ส่งคืน exit code

ลงทะเบียน hook PreToolUse ใน .claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/no-egress.sh"
          }
        ]
      }
    ]
  }
}

Hook จะได้รับ tool call ในรูปแบบ JSON ผ่านทาง standard input หาก exit code เป็น 2 จะเป็นการบล็อกการเรียกนั้นและแสดงเหตุผลจาก standard error ให้ Claude เห็น หาก exit code เป็น 0 จะอนุญาตให้การเรียกนั้นดำเนินการผ่านขั้นตอนการอนุญาตตามปกติ

#!/usr/bin/env bash
# PreToolUse: stdin holds the tool call, exit 2 blocks it.
cmd=$(jq -r '.tool_input.command // ""')
if printf '%s' "$cmd" | grep -qE '(^|[;&|]|\s)(curl|wget|nc|ncat)(\s|$)'; then
  echo "Blocked: this repository does not allow outbound network commands." >&2
  exit 2
fi
exit 0

ตอนนี้เข้าสู่ส่วนที่เป็นความจริง นี่คือรายการปฏิเสธ (denylist) ที่ครอบคลุม shell string และรายการปฏิเสธที่ครอบคลุม shell string มักจะมีช่องโหว่ python3 -c สามารถเปิดซ็อกเก็ตได้โดยไม่ต้องใช้คำว่า curl เป้าหมาย make deploy สามารถซ่อนการเรียกเดียวกันไว้ลึกลงไปอีกระดับหนึ่ง ให้เขียน hooks สำหรับข้อผิดพลาดที่คุณระบุได้ และวางขอบเขตที่คุณเชื่อถือได้จริงไว้ในเคอร์เนลหรือบนเครือข่าย

กฎการปฏิเสธการอนุญาตมีขีดจำกัดในการจับคู่ที่ควรทราบ กฎการปฏิเสธ Read และ Edit ครอบคลุมเครื่องมือจัดการไฟล์ของ Claude เองและคำสั่งไฟล์ที่ Claude รู้จักใน Bash เช่น cat, head, tail และ sed แต่ไม่ครอบคลุมสคริปต์ Python หรือ Node ที่เปิดไฟล์ด้วยตัวเอง กฎจะถูกประเมินโดยให้ความสำคัญกับการปฏิเสธก่อน จากนั้นจึงถาม และสุดท้ายคืออนุญาต ดังนั้นกฎการปฏิเสธจึงไม่สามารถมีข้อยกเว้นแบบอนุญาตได้

{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(./secrets/**)",
      "Bash(git push *)"
    ]
  }
}

ตรวจสอบสิ่งที่ออกไป และอ่าน diff

การรันเอเจนต์จะสร้าง diff และชุดคำขอเครือข่าย ทั้งสองอย่างควรได้รับการตรวจสอบก่อนที่จะมีการ merge หรือ deploy การทำ การตรวจสอบความปลอดภัยแบบ self-hosted บน diff จะช่วยตรวจจับการเปลี่ยนแปลงในรูปแบบที่ต่างจากการที่มนุษย์กวาดสายตามอง และ การรู้ว่าเอเจนต์เขียนโค้ดส่งอะไรออกไปบ้าง จะช่วยให้คุณทราบว่าทราฟฟิกปกติมีลักษณะอย่างไร เพื่อให้คำขอที่ผิดปกติสามารถสังเกตเห็นได้ชัดเจนขึ้น

สิ่งที่ยังแก้ไม่ได้

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

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

งานที่มีแนวโน้มดีที่สุดอยู่ที่ระดับการออกแบบ ไม่ใช่ระดับ model CaMeL จาก Defeating Prompt Injections by Design (Debenedetti และคณะ, 2025) จะแยก control flow และ data flow จากคำขอที่เชื่อถือได้ก่อน เพื่อไม่ให้ข้อมูลที่ไม่เชื่อถือเปลี่ยนการทำงานของโปรแกรม จากนั้นจึงบังคับใช้การตรวจสอบ capability เมื่อมีการเรียกใช้ tools ตัวเลขของบทความเองจาก benchmark AgentDojo แสดงให้เห็นว่าการออกแบบนี้มีต้นทุนเท่าใด

แผนภูมิAgentDojo tasks solved, published figures from the CaMeL paper (2025)
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "Undefended agent",
    "tasks_solved_pct": 84
  },
  {
    "label": "CaMeL",
    "tasks_solved_pct": 77
  }
]

Agent ที่ไม่มีการป้องกันทำงานสำเร็จ 84 เปอร์เซ็นต์ของ task ส่วน CaMeL ทำงานสำเร็จ 77 เปอร์เซ็นต์ พร้อม security guarantee ตัวเลขเหล่านี้เป็นตัวเลขที่บทความเผยแพร่สำหรับ benchmark เดียว และไม่ใช่การวัด workload ของคุณ ช่องว่างระหว่างตัวเลขทั้งสองโดยคร่าวคือราคาของการรับประกันที่ใช้งานได้จริงในปัจจุบัน

จนกว่าการออกแบบลักษณะนี้จะมีให้ใช้งานใน tools ที่คุณใช้เป็นประจำ ให้เตรียมรับว่า agent อาจถูก compromise ได้ในสักวันหนึ่ง และทำให้เหตุการณ์นั้นไม่ก่อความยุ่งยาก นี่คือเหตุผลทั้งหมดที่ควรใช้เครื่องที่ทิ้งได้, scoped credentials, ควบคุม egress และสร้างนิสัยตรวจสอบ diff

FAQ

ฉันหยุด prompt injection ได้หรือไม่ หากบอก agent ให้เพิกเฉยต่อคำสั่งในไฟล์

ไม่ได้ ข้อความนั้นอยู่ใน context window เดียวกับการโจมตี และมีน้ำหนักเท่ากับข้อความของผู้โจมตี Claude Code ระบุขอบเขตไว้อย่างชัดเจนว่า คำสั่งใน prompt หรือ CLAUDE.md กำหนดสิ่งที่ agent พยายามทำ และไม่ได้เปลี่ยนแปลงสิ่งที่เครื่องมืออนุญาต ให้ถือว่าไฟล์คำสั่งเป็นเพียงการระบุเจตนา และนำสิ่งที่ต้องพึ่งพาไปกำหนดไว้ในกฎ permission, hook ของ PreToolUse หรือกฎ firewall

prompt injection เป็นความเสี่ยงจริงหรือไม่ หาก agent เข้าถึงเฉพาะ repository ของฉันเอง

เป็นความเสี่ยงจริง เพราะ repository ของคุณเต็มไปด้วยข้อความที่คุณไม่ได้เขียน ไฟล์ README ของ dependency, URL ใน lockfile, test fixture, โค้ดที่ vendored และ output ของ npm install ล้วนถูกนำเข้ามาระหว่างงานตามปกติ สิ่งใดก็ตามที่ดึงมาจาก issue tracker หรือเว็บไซต์เอกสารก็เข้ามาในลักษณะเดียวกัน ความเสี่ยงจะเพิ่มขึ้นตามปริมาณข้อมูลที่ agent อ่าน และ agent ที่มีประโยชน์มักอ่านข้อมูลจำนวนมาก

การเรียกใช้ agent ใน container แก้ปัญหานี้ได้หรือไม่

ช่วยจำกัดความเสียหายได้ แต่จะได้ผลก็ต่อเมื่อคุณนำ credentials ออกไปด้วย หาก forward SSH agent, ใส่ cloud credentials ไว้ใน environment และเปิด network access แบบไม่จำกัดให้ container ผู้โจมตีก็จะเข้าถึงเกือบทุกอย่างที่ host เข้าถึงได้ สิ่งที่ container ช่วยได้จริงคือมี filesystem ที่ลบทิ้งได้ และมีพื้นที่สะอาดสำหรับบังคับใช้กฎ egress ควรใช้ร่วมกับ token ที่จำกัดขอบเขตไว้กับ repository เดียว

การเปลี่ยนแปลงเพียงอย่างเดียวที่ลดความเสี่ยงได้มากที่สุดคืออะไร

นำ credentials ที่มีอายุยาวออกจาก environment ที่คำสั่งของ agent สืบทอดมา จากนั้นกำหนด default-deny egress policy ให้กับเครื่องนั้น ทั้งสองอย่างนี้ตัดเงื่อนไขข้อที่สามของ lethal trifecta ได้ ข้อความยังสามารถ hijack agent ได้ แต่ข้อมูลที่ agent เข้าถึงจะไม่สามารถนำไปใช้ต่อได้อย่างมีประโยชน์ approval prompt และการตรวจสอบ diff ก็ช่วยได้เช่นกัน แต่ทั้งสองอย่างต้องอาศัยมนุษย์ที่มีสมาธิตลอดการทำงานระยะยาว จึงมีความสำคัญรองลงมาจากการเปลี่ยนแปลง 2 ข้อนี้

บทความนี้มีประโยชน์หรือไม่