SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-21

Coding agents में prompt injection से सुरक्षा कैसे करें

Coding agents में prompt injection के खतरों को समझें। हम सर्वर पर मौजूद injection surfaces का विश्लेषण करते हैं और उन बचाव के उपायों को रैंक करते हैं जो वास्तव में प्रभावी हैं।

Coding agent के खिलाफ prompt injection क्या है

Coding agent के खिलाफ prompt injection को समझना सरल है: agent जो भी text पढ़ता है, उसे एक निर्देश मानकर उसका पालन करता है। Agent कोई file, pull request comment, web page या tool call का परिणाम खोलता है। यह सब आपके अपने अनुरोध (request) की तरह ही text के रूप में आता है। यदि कोई हमलावर (attacker) उस text के किसी भी हिस्से को नियंत्रित करता है, तो वह आपके session में कुछ भी लिख रहा है।

वर्तमान में उपलब्ध हर agent product में यह विशेषता है। Model को tokens का एक ही sequence प्राप्त होता है। आपका अनुरोध, system prompt, file की सामग्री और tool के परिणाम सब एक साथ जुड़ जाते हैं, और model यह अनुमान लगाता है कि आगे क्या आएगा। किसी भी token पर कोई privilege bit नहीं होता है। format में ऐसा कुछ भी नहीं है जो यह बताए कि कौन सा हिस्सा आपके द्वारा अधिकृत है और कौन सा किसी अजनबी की README file से आया है।

यह पृष्ठ threat model है: जहाँ हमलावर द्वारा नियंत्रित text किसी सर्वर पर चल रहे agent तक पहुँचता है, प्रत्येक बिंदु पर हमलावर को क्या प्राप्त होता है, और कौन से बचाव के उपाय सार्थक हैं। हमारे अन्य guides में दी गई containment सलाह तभी समझ में आती है जब आप यह जान लें कि आप agent को किस चीज़ से सुरक्षित (contain) कर रहे हैं।

मॉडल सामग्री और निर्देशों को अलग क्यों नहीं कर सकता

Training सहायता करता है, लेकिन समस्या का समाधान नहीं करता। वर्तमान models retrieved text को संदेह की दृष्टि से देखने के लिए train किए जाते हैं और कई सतही प्रयासों को अस्वीकार करते हैं। अस्वीकार करना एक probability है, कोई rule नहीं। Attacker शब्दों को बदल सकता है, बार-बार प्रयास कर सकता है और text को ऐसे format में छिपा सकता है जिसकी किसी ने योजना नहीं बनाई थी। उसके द्वारा आजमाए जा सकने वाले wording की संख्या पर कोई सीमा नहीं होती।

OWASP GenAI project इसे LLM01:2026 Prompt Injection के रूप में track करता है। यह LLM Applications के लिए उसके 2026 Top 10 में पहली entry है और इसे दो भागों में बाँटा गया है। Direct injection वह input है जो user या user की access रखने वाला attacker सीधे model को देता है और जिससे model का behaviour बदल जाता है। Indirect injection में कोई external content, जैसे website या file, model द्वारा process किए जाने पर उसका behaviour बदलता है। Server पर Indirect injection अधिक महत्वपूर्ण है, क्योंकि agent आपके द्वारा type किए गए text से कहीं अधिक text पढ़ता है।

इस विषय पर पहला systematic study Greshake और उनके colleagues का Not what you've signed up for (2023) है। उनका निष्कर्ष याद रखने योग्य है: जब कोई application ऐसे model में retrieved text feed करती है जो tools call कर सकता है, तो उस text को process करना लगभग arbitrary code execution के समान होता है।

वह स्थिति जो एक read को breach में बदल देती है

hostile text को पढ़ना अपने आप में नुकसान नहीं है। नुकसान के लिए मशीन से बाहर निकलने का एक रास्ता चाहिए।

Simon Willison ने जून 2025 में इस संयोजन को the lethal trifecta नाम दिया। एक ऐसा agent जिसके पास private data हो, जो untrusted content के संपर्क में हो, और जो data बाहर भेज सकता हो, उसे पहले वाले data को तीसरे रास्ते से बाहर भेजने के लिए राजी किया जा सकता है।

आपके VPS पर मौजूद एक coding agent के पास पहले दिन से ही ये तीनों चीजें होती हैं। private data आपका source code, आपकी .env file, आपकी SSH keys और आपकी shell history है। untrusted content वह हर repository, page और tool का result है जिसे वह पढ़ता है। बाहर निकलने का रास्ता git push, curl, npm publish, एक pull request body, या आपके terminal में print हुआ कोई link है जिस पर आप click करते हैं।

आप दूसरी स्थिति को नहीं हटा सकते, क्योंकि untrusted text को पढ़ना ही वह काम है जिसके लिए आपने agent को hire किया है। इसलिए हर व्यावहारिक बचाव बाकी दो स्थितियों पर काम करता है।

जहाँ अविश्वसनीय टेक्स्ट सर्वर पर कोडिंग एजेंट तक पहुँचता है

वह रिपॉजिटरी जिसमें एजेंट काम कर रहा है

चेकआउट में मौजूद हर फाइल इनपुट है। सोर्स कमेंट्स, README.md, चेंजलॉग, टेस्ट फिक्स्चर, वेंडर्ड कोड, और स्वयं एजेंट इंस्ट्रक्शन फाइलें: CLAUDE.md, AGENTS.md और उनके समकक्ष। जिस एजेंट को कोडबेस समझने के लिए कहा जाता है, वह इन्हें पढ़ता है, क्योंकि आपने यही करने के लिए कहा है।

यहाँ हमलावर को यह लाभ मिलता है कि वह उन सभी लोगों तक पहुँच बना सकता है जो रिपॉजिटरी को क्लोन करते हैं और उस पर एजेंट को पॉइंट करते हैं। इंस्ट्रक्शन फाइलें सबसे सीधा रास्ता हैं, क्योंकि वे निर्देशों के रूप में पढ़े जाने के लिए ही मौजूद होती हैं। एक पुल रिक्वेस्ट जो CLAUDE.md में चार उपयोगी लाइनें जोड़ती है और एक लाइन ऐसी जोड़ती है जो एजेंट को रीडायरेक्ट करती है, वह ऐसा बदलाव है जिसे मानव समीक्षक सरसरी तौर पर देखकर छोड़ देते हैं।

इश्यूज, पुल रिक्वेस्ट और कोड रिव्यू कमेंट्स

कोई भी अजनबी आपके ट्रैकर में जो कुछ भी टाइप कर सकता है, वह उस पल एजेंट तक पहुँच जाता है जब आप उसे ट्राइएज (triage) करने के लिए कहते हैं। मई 2025 में, Invariant Labs ने इसी तरह का एक GitHub MCP finding प्रकाशित किया था। एक डेवलपर के एजेंट की पहुँच एक पब्लिक रिपॉजिटरी और कुछ प्राइवेट रिपॉजिटरीज तक थी। एक हमलावर ने पब्लिक रिपॉजिटरी में एक इश्यू फाइल किया। जब डेवलपर ने एजेंट को ओपन इश्यूज देखने के लिए कहा, तो एजेंट ने प्राइवेट रिपॉजिटरी की सामग्री पढ़ ली और उसे पब्लिक साइड पर एक पुल रिक्वेस्ट में लिख दिया।

वह रिपोर्ट MCP सर्वर में किसी कोड डिफेक्ट के बजाय एक आर्किटेक्चरल समस्या का वर्णन करती है। एजेंट के पास एक व्यापक एक्सेस टोकन था, उसने पब्लिक इनबॉक्स से पढ़ा, और उसके पास लिखने की अनुमति थी। सामान्य अर्थों में कुछ भी गलत कॉन्फ़िगर नहीं था, इसीलिए इसका समाधान पैचिंग नहीं बल्कि स्कोपिंग (scoping) है।

वेब पेज जिन्हें एजेंट फेच (fetch) करता है

डॉक्यूमेंटेशन, फोरम के जवाब, वेंडर पेज, सर्च रिजल्ट। इनमें से कोई भी ऐसा टेक्स्ट ले जा सकता है जो आपके लिए नहीं, बल्कि एजेंट के लिए लिखा गया हो। HTML को टेक्स्ट में बदलने से हमलावर को अतिरिक्त जगह मिल जाती है, क्योंकि जो कंटेंट ब्राउज़र कभी प्रदर्शित नहीं करता, वह भी मॉडल तक पहुँच जाता है।

हमलावर को उस समय नियंत्रण मिल जाता है जब एजेंट पर सबसे कम निगरानी होती है। जब एजेंट कुछ खोजते समय कोई पेज फेच करता है, तो कोई भी उस पेज का पूरा टेक्स्ट नहीं पढ़ता।

MCP टूल आउटपुट

MCP (model context protocol) वह सामान्य तरीका है जिससे एजेंट बाहरी टूल्स से जुड़ते हैं। परिणाम टेक्स्ट के रूप में वापस आते हैं और सीधे कॉन्टेक्स्ट विंडो में चले जाते हैं। यहाँ एक नहीं, बल्कि दो सरफेस (सतह) हैं। टूल द्वारा लौटाया गया डेटा स्पष्ट है। टूल का अपना नाम और विवरण, जिसे मॉडल यह तय करने के लिए पढ़ता है कि उसे कब कॉल करना है, दूसरा सरफेस है, और जिस सर्वर को आप कंट्रोल नहीं करते, वह कॉल के बीच में इनमें से किसी को भी बदल सकता है।

एक हमलावर जो किसी एक टूल के आउटपुट में टेक्स्ट डाल देता है, वह एजेंट के पास मौजूद हर दूसरे टूल तक पहुँच जाता है। इसी तरह कम महत्व वाली चीज में किया गया इंजेक्शन अंततः उच्च महत्व वाली चीज को नियंत्रित करने का कारण बनता है।

CI लॉग्स, बिल्ड आउटपुट और डिपेंडेंसी मेटाडेटा

npm install उन पैकेजों से टेक्स्ट प्रिंट करता है जिन्हें आपने नहीं लिखा है। एक टेस्ट फेलियर किसी लाइब्रेरी से एक असर्शन मैसेज प्रिंट करता है। एक कंटीन्यूअस इंटीग्रेशन (CI) जॉब लॉग में हजारों लाइनें थर्ड-पार्टी आउटपुट की होती हैं। किसी एजेंट को फेल हो रहे बिल्ड को ठीक करने के लिए कहें और वह यह सब पढ़ लेता है।

यहाँ हमलावर को बिल्ड मशीन का एक्सेस मिल जाता है, जिसमें आमतौर पर डिप्लॉय क्रेडेंशियल्स और रजिस्ट्री टोकन होते हैं और जिस पर लैपटॉप की तुलना में कम ध्यान दिया जाता है।

हमलावर को वास्तव में क्या मिलता है

चार परिणाम ऐसे हैं जिनके लिए योजना बनाना आवश्यक है।

Credential की चोरी। एजेंट प्रोसेस जो कुछ भी पढ़ सकता है, वह दायरे में है: environment variables, ~/.aws/credentials, ~/.ssh, एक gh टोकन, या एक Docker config फ़ाइल। उन्हें बाहर भेजने के लिए curl की आवश्यकता नहीं होती है। किसी branch में commit, pull request का विवरण, registry में पब्लिश किया गया पैकेज, या हमलावर द्वारा नियंत्रित नाम के लिए DNS lookup, ये सभी डेटा को सर्वर से बाहर ले जाते हैं।

आपके द्वारा स्वीकृत कोड में बदलाव। कोड लिखना ही एजेंट का काम है, इसलिए उससे कोड में एक सूक्ष्म गलत लाइन लिखवाना सबसे आसान परिणाम है। एक अतिरिक्त dependency, या एक logging call जो किसी टोकन को ऐसे लॉग में ले जाती है जिसे आप कहीं और भेजते हैं।

Persistence (स्थायित्व)। एक बार लिखी गई फ़ाइल बिना किसी मॉडल के काम करती रहती है: .git/hooks में एक hook, package.json में एक postinstall स्क्रिप्ट, shell startup फ़ाइल में जोड़ी गई एक लाइन, या CLAUDE.md में एक अतिरिक्त लाइन। अगली कमांड इसे चला देती है।

आपके नेटवर्क के भीतर मूवमेंट। एजेंट वहीं चलता है जहाँ आप उसे रखते हैं। यदि वह सर्वर loopback पर किसी database, किसी internal admin service, आपके cloud provider की metadata service, या private network पर किसी अन्य host तक पहुँच सकता है, तो एजेंट को नियंत्रित करने वाली कोई भी चीज़ भी वहाँ तक पहुँच सकती है।

Auto-approve modes अंतिम जाँच हटा देते हैं

Manual mode में, जिसका config value default है, Claude Code किसी command को चलाने या file में बदलाव करने से पहले आपसे पूछता है। यह prompt ऊपर बताए गए हर स्तर और वास्तविक action के बीच मानव जाँच का काम करता है। जिन modes में prompt नहीं दिखता, उनमें यह जाँच भी नहीं रहती। Claude Code v2.1.283 के बाद session Manual mode से शुरू नहीं होता: interactive terminal और VS Code sessions auto mode में शुरू होते हैं, जब तक कोई setting दूसरा mode निर्धारित न करे (October 2026 में जाँचा गया)।

bypassPermissions के बारे में documentation स्पष्ट है: इसका उपयोग केवल containers या VMs जैसे isolated environments में करें, जहाँ Claude Code नुकसान नहीं पहुँचा सकता। Auto mode कम कठोर है: एक अलग classifier model actions चलने से पहले उनकी समीक्षा करता है और ऐसे actions को block करता है जो आपके request से आगे बढ़ते हों, अपरिचित infrastructure को target करते हों या Claude द्वारा पढ़ी गई hostile content से प्रेरित लगते हों। ये checks बहुत कुछ पकड़ लेते हैं। फिर भी ये model output के बारे में model का judgement हैं, इसलिए इन्हें boundary नहीं, बल्कि filter मानें।

Prompt बनाए रखने के लिए permissions.defaultMode को "default" (या इसके alias "manual") पर ~/.claude/settings.json या project के .claude/settings.json में set करें। Administrator बाकी दोनों modes को पूरी तरह हटा सकता है। किसी settings file में permissions.disableBypassPermissionsMode या permissions.disableAutoMode को "disable" पर set करें और उस file को managed settings में रखें, ताकि checked-out project इसे override न कर सके। हमारा Claude Code auto mode और permission rules संबंधी guide बताता है कि प्रत्येक rule कहाँ प्रभावी होता है।

सुरक्षाएँ, उनके लाभ के आधार पर क्रमबद्ध

इनमें से कोई भी पूर्ण समाधान नहीं है। हर उपाय या तो agent के पास मौजूद चीजों का दायरा घटाता है, या उन चीजों के उपयोग की क्षमता सीमित करता है।

  1. ऐसी मशीन जिसे आप नष्ट करके फिर से बना सकें, ताकि compromise की कीमत incident के बजाय आपका एक घंटा हो।
  2. आपके credentials से अलग credentials, जो केवल एक repository तक सीमित हों और कम समय के लिए मान्य हों।
  3. उस environment में कोई लंबे समय तक मान्य secret न हो, जिसे agent के commands inherit करते हैं।
  4. Network egress और file access पर operating system enforcement, जो agent द्वारा शुरू किए गए हर process पर लागू हो।
  5. Writes और network calls के लिए approval prompts चालू रखना।
  6. उन विशिष्ट actions के लिए hooks, जिन्हें आप स्पष्ट रूप से परिभाषित कर सकते हैं।
  7. Merge करने से पहले diff पढ़ना।

क्रम महत्वपूर्ण है। Items 1 से 4 तब भी लागू रहते हैं, जब model पूरी तरह attacker के नियंत्रण में हो। Items 5 से 7 इस बात पर निर्भर करते हैं कि कोई human ध्यान दे। लंबे agent run के दौरान ठीक यही ध्यान देना बंद हो जाता है।

Agent को ऐसी मशीन पर चलाएँ जिसे आप फेंक सकें

ऐसा VPS, जिसमें केवल एक checkout और एक scoped token हो, उस laptop से बहुत कम मूल्यवान target है जिसमें आपके keys मौजूद हों। Agent को अपने अलग unprivileged user के रूप में चलाएँ। इसे अपने login account या root के रूप में न चलाएँ। coding agents के लिए disposable VM और VPS पर least-privilege users संबंधी हमारी guides setup समझाती हैं। VPS पर Claude Code को सुरक्षित रूप से चलाना इसके दैनिक उपयोग का तरीका बताता है।

Secrets को environment से बाहर रखें

Environment variable को हर child process पढ़ सकता है। इसका अर्थ है कि agent द्वारा चलाया गया हर command उसे पढ़ सकता है। Claude Code का sandbox हर sandboxed command से पहले नामित variables को unset कर सकता है। Linux पर sandbox के लिए पहले दो packages चाहिए:

sudo apt-get install bubblewrap socat

Ubuntu 24.04 और उसके बाद के versions में default AppArmor policy bubblewrap को आवश्यक user namespaces बनाने से रोकती है। यदि sysctl kernel.apparmor_restrict_unprivileged_userns का परिणाम 1 हो, तो Claude Code sandboxing documentation में दिया गया bwrap का छोटा AppArmor profile जोड़ें। फिर AppArmor reload करें।

इसके बाद ~/.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 entry हर sandboxed command चलने से पहले उस variable को unset करती है। allowedDomains उन hosts की सूची दिखाता है, जिन तक sandboxed commands पहुँच सकते हैं। strictAllowlist के बिना, उस सूची से बाहर के host के लिए आपका permission mode तय करता है कि क्या होगा: Manual mode आपसे prompt के माध्यम से अनुमति माँगता है, जबकि auto mode एक command के लिए classifier को अतिरिक्त hosts खोलने देता है। इसके बजाय strictAllowlist हर unlisted host को अस्वीकार करता है। इसके लिए Claude Code v2.1.219 या बाद का version चाहिए। यह केवल user या managed settings से प्रभावी होता है, इसलिए कोई repository इसे बंद नहीं कर सकती (October 2026 में जाँचा गया)। credentials block के लिए Claude Code v2.1.187 या बाद का version चाहिए, जिसे August 2026 में जाँचा गया था। किसी session में /sandbox चलाकर देखें कि कौन-सी layers सक्रिय हैं और कौन-सी dependencies missing हैं। इस machine पर वास्तव में कौन-से secrets मौजूद होने चाहिए, यह तय करना इस काम का बड़ा हिस्सा है। secrets को AI agent की पहुँच से दूर रखना इस विषय को विस्तार से समझाता है।

Operating system पर network egress सीमित करें

Firewall rule को इस बात से कोई फर्क नहीं पड़ता कि model ने क्या तय किया। Agent को dedicated agent user के रूप में चलाएँ। फिर उस user द्वारा भेजे जाने वाले traffic को drop करें:

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 user के लिए केवल loopback बचता है। इसलिए उसका traffic उसी box पर चलने वाले proxy से होकर जाना होगा। Hostname allowlist proxy के पास रहेगी। https_proxy को उस proxy की ओर point करने पर client CONNECT request भेजता है और proxy name lookup करता है। इसलिए agent को अपना outbound DNS (domain name system) नहीं चाहिए। sudo nft list ruleset से अपना काम जाँचें। Agent जब किसी नए destination तक पहुँचने का प्रयास करे, तब drop rule का counter बढ़ता हुआ देखें।

Firewall changes लागू करते समय दूसरी SSH session खुली रखें। यह भी जाँचें कि आपका container runtime इन rules के साथ क्या करता है। Docker अपनी chains लिखता है। published Docker ports ufw को bypass करते हैं उस समस्या का वर्णन करता है।

Hooks: वह जाँच जिसे model तर्क देकर पार नहीं कर सकता

Permission rules और hooks को model नहीं, Claude Code लागू करता है। Documentation इसे स्पष्ट रूप से बताती है: आपके prompt या CLAUDE.md में दिए गए instructions यह तय करते हैं कि Claude क्या करने का प्रयास करेगा। वे यह नहीं बदलते कि Claude Code किस action की अनुमति देता है। यही अंतर इन controls का पूरा मूल्य है। CLAUDE.md में "never run curl" लिखी पंक्ति केवल एक suggestion है, जिससे injected paragraph बहस कर सकता है। Hook एक ऐसा process है, जो exit code लौटाता है।

PreToolUse hook को .claude/settings.json में register करें:

{
  "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 call को block करता है और standard error से प्राप्त कारण Claude को दिखाता है। Exit code 0 call को सामान्य permission flow से आगे बढ़ने देता है।

#!/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

अब सीमाएँ स्पष्ट रूप से समझें। यह shell string पर आधारित denylist है, और shell strings पर आधारित denylists में कमियाँ रहती हैं। python3 -c शब्द curl का उपयोग किए बिना socket खोलता है। make deploy target उसी call को एक स्तर और नीचे छिपा देता है। जिन mistakes को आप नाम से पहचान सकते हैं, उनके लिए hooks लिखें। जिस boundary पर आप वास्तव में निर्भर हैं, उसे kernel या network पर लागू करें।

Permission deny rules की matching limit भी ध्यान देने योग्य है। Read और Edit deny rules Claude के अपने file tools और Bash में पहचाने जाने वाले file commands पर लागू होते हैं, जैसे cat, head, tail और sed। वे ऐसे Python या Node script पर लागू नहीं होते, जो स्वयं file खोलती है। Rules का मूल्यांकन पहले deny, फिर ask और उसके बाद allow क्रम में होता है। इसलिए deny rule में allowlist exception नहीं जोड़ा जा सकता।

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

क्या बाहर जा रहा है देखें और diff पढ़ें

Agent run से एक diff और network calls का एक set बनता है। किसी भी चीज को merge या deploy करने से पहले दोनों की जाँच करें। self-hosted security review pass diff में ऐसे बदलाव पकड़ता है, जिन्हें human द्वारा केवल सरसरी तौर पर पढ़ने पर नज़रअंदाज़ किया जा सकता है। यह जानना कि coding agent box से बाहर क्या भेजता है आपको सामान्य traffic समझने में मदद करता है, ताकि असामान्य request तुरंत दिखाई दे।

क्या अभी भी अनसुलझा है

आज कंटेंट और इंस्ट्रक्शन के बीच कोई विश्वसनीय अलगाव नहीं है। जो भी सुरक्षा उपाय (defences) उपलब्ध हैं, वे या तो एक निश्चित विफलता दर वाले फिल्टर हैं या परिणामों पर लगाई गई सीमाएं हैं। स्टैक में ऐसा कुछ भी नहीं है जो टेक्स्ट के किसी हिस्से को डेटा के रूप में चिह्नित करे जिसका पालन कभी नहीं किया जाना चाहिए।

फिल्टर मदद तो करते हैं, लेकिन वे विफल भी होते हैं। एक क्लासिफायर जो अधिकांश इंजेक्शन प्रयासों को पकड़ लेता है, उसे हर बार सही होना पड़ता है, जबकि एक हमलावर को केवल एक बार सही होने की आवश्यकता होती है। यही विषमता कारण है कि किसी सुरक्षा उपाय की प्रकाशित सफलता दर अगले हमले के लिए एक शुरुआती बिंदु है, न कि कोई गारंटी।

सबसे आशाजनक कार्य मॉडल स्तर के बजाय डिज़ाइन स्तर पर हो रहे हैं। Defeating Prompt Injections by Design (Debenedetti और सहयोगी, 2025) से CaMeL, सबसे पहले विश्वसनीय अनुरोध से कंट्रोल फ्लो और डेटा फ्लो को अलग करता है, ताकि अविश्वसनीय डेटा प्रोग्राम के कार्य करने के तरीके को न बदल सके, और फिर टूल कॉल किए जाने पर क्षमता जांच (capability checks) लागू करता है। AgentDojo बेंचमार्क पर शोध पत्र के अपने आंकड़े दिखाते हैं कि इसकी क्या लागत है।

चार्टAgentDojo tasks solved, published figures from the CaMeL paper (2025)
इस चार्ट के पीछे का डेटा
[
  {
    "label": "Undefended agent",
    "tasks_solved_pct": 84
  },
  {
    "label": "CaMeL",
    "tasks_solved_pct": 77
  }
]

बिना सुरक्षा वाले एजेंट ने 84 प्रतिशत कार्यों को हल किया। CaMeL ने सुरक्षा गारंटी के साथ 77 प्रतिशत कार्यों को हल किया। ये एक बेंचमार्क पर शोध पत्र के प्रकाशित आंकड़े हैं और आपके वर्कलोड का माप नहीं हैं। उनके बीच का अंतर लगभग वही है जो आज एक वास्तविक सुरक्षा गारंटी की कीमत है।

जब तक आपके द्वारा प्रतिदिन उपयोग किए जाने वाले टूल में इस तरह का डिज़ाइन शामिल नहीं हो जाता, तब तक यह मानकर चलें कि एजेंट किसी न किसी बिंदु पर ब्रीच (compromise) हो जाएगा और उस घटना को सामान्य (boring) बनाएं। डिस्पोजेबल मशीन, सीमित क्रेडेंशियल्स, नियंत्रित इग्रेस (egress) और डिफ (diff) पढ़ने की आदत का पूरा तर्क यही है।

FAQ

क्या मैं एजेंट को फाइलों में दिए गए निर्देशों को अनदेखा करने के लिए कहकर prompt injection को रोक सकता हूँ?

नहीं। वह वाक्य उसी context window में मौजूद टेक्स्ट है जिसमें हमला (attack) है, और यह हमलावर के टेक्स्ट के साथ समान स्तर पर प्रतिस्पर्धा करता है। Claude Code का documentation स्पष्ट रूप से सीमा निर्धारित करता है: आपके prompt या CLAUDE.md में दिए गए निर्देश यह तय करते हैं कि एजेंट क्या करने की कोशिश करता है, लेकिन वे यह नहीं बदलते कि tool क्या करने की अनुमति देता है। निर्देश वाली फाइल को केवल इरादे के बयान के रूप में देखें, और जिस भी चीज़ पर आप भरोसा करते हैं उसे permission rules, PreToolUse hook या firewall rule में रखें।

क्या prompt injection एक वास्तविक जोखिम है यदि एजेंट केवल मेरी अपनी repository को छूता है?

हाँ, क्योंकि आपकी repository ऐसे टेक्स्ट से भरी है जिसे आपने नहीं लिखा है। Dependency README फाइलें, lockfile URLs, test fixtures, vendored code और npm install का आउटपुट, ये सभी एक सामान्य कार्य के दौरान आते हैं। Issue tracker या documentation साइट से ली गई कोई भी चीज़ उसी तरह आती है। जोखिम इस बात के साथ बढ़ता है कि एजेंट कितना पढ़ता है, और एक उपयोगी एजेंट बहुत कुछ पढ़ता है।

क्या एजेंट को container में चलाने से यह समस्या हल हो जाती है?

यह नुकसान को सीमित करता है, और वह भी केवल तब जब आप credentials को भी हटा दें। एक container जिसमें आपका SSH agent forward किया गया हो, environment में cloud credentials हों और unrestricted network access हो, वह हमलावर को लगभग वह सब कुछ दे देता है जो host के पास होता है। Container वास्तव में आपको एक ऐसा filesystem देता है जिसे आप delete कर सकते हैं और egress rules लागू करने के लिए एक साफ जगह देता है। इसे एक ऐसी token के साथ जोड़ें जो केवल एक repository तक सीमित हो।

कौन सा एक बदलाव जोखिम को सबसे अधिक कम करता है?

एजेंट द्वारा run की जाने वाली commands के environment से long-lived credentials को हटा दें, और फिर उस machine को default-deny egress policy दें। ये दोनों मिलकर घातक तिकड़ी (lethal trifecta) की तीसरी शर्त को तोड़ देते हैं: टेक्स्ट अभी भी एजेंट को hijack कर सकता है, लेकिन जिस डेटा तक वह पहुँचता है, उसे बाहर भेजने का कोई उपयोगी रास्ता नहीं बचता। Approval prompts और diff review भी मदद करते हैं, लेकिन वे इस बात पर निर्भर करते हैं कि एक लंबा कार्य चलने के दौरान इंसान सतर्क रहे, इसीलिए वे इन दो बदलावों से नीचे आते हैं।

क्या यह लेख उपयोगी था?